<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<title>Voro++: v_compute.cc Source File</title>

<link href="tabs.css" rel="stylesheet" type="text/css"/>
<link href="doxygen.css" rel="stylesheet" type="text/css" />



</head>
<body>
<div id="top"><!-- do not remove this div! -->


<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr style="height: 56px;">
  
  
  <td style="padding-left: 0.5em;">
   <div id="projectname">Voro++
   
   </div>
   
  </td>
  
  
  
 </tr>
 </tbody>
</table>
</div>

<!-- Generated by Doxygen 1.7.5.1 -->
<script type="text/javascript" src="dynsections.js"></script>
  <div id="navrow1" class="tabs">
    <ul class="tablist">
      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
      <li class="current"><a href="files.html"><span>Files</span></a></li>
    </ul>
  </div>
  <div id="navrow2" class="tabs2">
    <ul class="tablist">
      <li><a href="files.html"><span>File&#160;List</span></a></li>
      <li><a href="globals.html"><span>Globals</span></a></li>
    </ul>
  </div>
<div class="header">
  <div class="headertitle">
<div class="title">v_compute.cc</div>  </div>
</div>
<div class="contents">
<a href="v__compute_8cc.html">Go to the documentation of this file.</a><div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 <span class="comment">// Voro++, a 3D cell-based Voronoi library</span>
<a name="l00002"></a>00002 <span class="comment">//</span>
<a name="l00003"></a>00003 <span class="comment">// Author   : Chris H. Rycroft (LBL / UC Berkeley)</span>
<a name="l00004"></a>00004 <span class="comment">// Email    : chr@alum.mit.edu</span>
<a name="l00005"></a>00005 <span class="comment">// Date     : August 30th 2011</span>
<a name="l00006"></a>00006 <span class="comment"></span>
<a name="l00007"></a>00007 <span class="comment">/** \file v_compute.cc</span>
<a name="l00008"></a>00008 <span class="comment"> * \brief Function implementantions for the voro_compute template. */</span>
<a name="l00009"></a>00009 
<a name="l00010"></a>00010 <span class="preprocessor">#include &quot;<a class="code" href="worklist_8hh.html" title="Header file for setting constants used in the block worklists that are used during cell computation...">worklist.hh</a>&quot;</span>
<a name="l00011"></a>00011 <span class="preprocessor">#include &quot;<a class="code" href="v__compute_8hh.html" title="Header file for the voro_compute template and related classes.">v_compute.hh</a>&quot;</span>
<a name="l00012"></a>00012 <span class="preprocessor">#include &quot;<a class="code" href="container_8hh.html" title="Header file for the container_base and related classes.">container.hh</a>&quot;</span>
<a name="l00013"></a>00013 <span class="preprocessor">#include &quot;<a class="code" href="container__prd_8hh.html" title="Header file for the container_periodic_base and related classes.">container_prd.hh</a>&quot;</span>
<a name="l00014"></a>00014 
<a name="l00015"></a>00015 <span class="keyword">namespace </span>voro {
<a name="l00016"></a>00016 <span class="comment"></span>
<a name="l00017"></a>00017 <span class="comment">/** The class constructor initializes constants from the container class, and</span>
<a name="l00018"></a>00018 <span class="comment"> * sets up the mask and queue used for Voronoi computations.</span>
<a name="l00019"></a>00019 <span class="comment"> * \param[in] con_ a reference to the container class to use.</span>
<a name="l00020"></a>00020 <span class="comment"> * \param[in] (hx_,hy_,hz_) the size of the mask to use. */</span>
<a name="l00021"></a>00021 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00022"></a><a class="code" href="classvoro_1_1voro__compute.html#a03e689aa5bb5886cec3db68a692de122">00022</a> <a class="code" href="classvoro_1_1voro__compute.html#a03e689aa5bb5886cec3db68a692de122">voro_compute&lt;c_class&gt;::voro_compute</a>(c_class &amp;con_,<span class="keywordtype">int</span> hx_,<span class="keywordtype">int</span> hy_,<span class="keywordtype">int</span> hz_) :
<a name="l00023"></a>00023         con(con_), boxx(con_.boxx), boxy(con_.boxy), boxz(con_.boxz),
<a name="l00024"></a>00024         xsp(con_.xsp), ysp(con_.ysp), zsp(con_.zsp),
<a name="l00025"></a>00025         hx(hx_), hy(hy_), hz(hz_), hxy(hx_*hy_), hxyz(hxy*hz_), ps(con_.ps),
<a name="l00026"></a>00026         id(con_.id), p(con_.p), co(con_.co), bxsq(boxx*boxx+boxy*boxy+boxz*boxz),
<a name="l00027"></a>00027         mv(0), qu_size(3*(3+hxy+hz*(hx+hy))), wl(con_.wl), mrad(con_.mrad),
<a name="l00028"></a>00028         mask(new unsigned int[hxyz]), qu(new int[qu_size]), qu_l(qu+qu_size) {
<a name="l00029"></a>00029         reset_mask();
<a name="l00030"></a>00030 }
<a name="l00031"></a>00031 <span class="comment"></span>
<a name="l00032"></a>00032 <span class="comment">/** Scans all of the particles within a block to see if any of them have a</span>
<a name="l00033"></a>00033 <span class="comment"> * smaller distance to the given test vector. If one is found, the routine</span>
<a name="l00034"></a>00034 <span class="comment"> * updates the minimum distance and store information about this particle.</span>
<a name="l00035"></a>00035 <span class="comment"> * \param[in] ijk the index of the block.</span>
<a name="l00036"></a>00036 <span class="comment"> * \param[in] (x,y,z) the test vector to consider (which may have already had a</span>
<a name="l00037"></a>00037 <span class="comment"> *                    periodic displacement applied to it).</span>
<a name="l00038"></a>00038 <span class="comment"> * \param[in] (di,dj,dk) the coordinates of the current block, to store if the</span>
<a name="l00039"></a>00039 <span class="comment"> *                       particle record is updated.</span>
<a name="l00040"></a>00040 <span class="comment"> * \param[in,out] w a reference to a particle record in which to store</span>
<a name="l00041"></a>00041 <span class="comment"> *                  information about the particle whose Voronoi cell the</span>
<a name="l00042"></a>00042 <span class="comment"> *                  vector is within.</span>
<a name="l00043"></a>00043 <span class="comment"> * \param[in,out] mrs the current minimum distance, that may be updated if a</span>
<a name="l00044"></a>00044 <span class="comment"> *                    closer particle is found. */</span>
<a name="l00045"></a>00045 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00046"></a>00046 <span class="keyword">inline</span> <span class="keywordtype">void</span> <a class="code" href="classvoro_1_1voro__compute.html" title="Template for carrying out Voronoi cell computations.">voro_compute&lt;c_class&gt;::scan_all</a>(<span class="keywordtype">int</span> ijk,<span class="keywordtype">double</span> x,<span class="keywordtype">double</span> y,<span class="keywordtype">double</span> z,<span class="keywordtype">int</span> di,<span class="keywordtype">int</span> dj,<span class="keywordtype">int</span> dk,<a class="code" href="structvoro_1_1particle__record.html" title="Structure for holding information about a particle.">particle_record</a> &amp;w,<span class="keywordtype">double</span> &amp;mrs) {
<a name="l00047"></a>00047         <span class="keywordtype">double</span> x1,y1,z1,rs;<span class="keywordtype">bool</span> in_block=<span class="keyword">false</span>;
<a name="l00048"></a>00048         <span class="keywordflow">for</span>(<span class="keywordtype">int</span> l=0;l&lt;co[ijk];l++) {
<a name="l00049"></a>00049                 x1=p[ijk][ps*l]-x;
<a name="l00050"></a>00050                 y1=p[ijk][ps*l+1]-y;
<a name="l00051"></a>00051                 z1=p[ijk][ps*l+2]-z;
<a name="l00052"></a>00052                 rs=con.r_current_sub(x1*x1+y1*y1+z1*z1,ijk,l);
<a name="l00053"></a>00053                 <span class="keywordflow">if</span>(rs&lt;mrs) {mrs=rs;w.<a class="code" href="structvoro_1_1particle__record.html#a5faf0f540ad3ee3ffcee5cae5a8b20fc">l</a>=l;in_block=<span class="keyword">true</span>;}
<a name="l00054"></a>00054         }
<a name="l00055"></a>00055         <span class="keywordflow">if</span>(in_block) {w.<a class="code" href="structvoro_1_1particle__record.html#ac65fa5fc929dda2dd454369eab68ef8b">ijk</a>=ijk;w.<a class="code" href="structvoro_1_1particle__record.html#a36ea6a17eb9dc145a3e5f14720b30d15">di</a>=di;w.<a class="code" href="structvoro_1_1particle__record.html#a25c3b01e32ccdb6bb37e279f14899bab">dj</a>=dj,w.<a class="code" href="structvoro_1_1particle__record.html#a56e78394cc8a114cedf353a2d54c0077">dk</a>=dk;}
<a name="l00056"></a>00056 }
<a name="l00057"></a>00057 <span class="comment"></span>
<a name="l00058"></a>00058 <span class="comment">/** Finds the Voronoi cell that given vector is within. For containers that are</span>
<a name="l00059"></a>00059 <span class="comment"> * not radially dependent, this corresponds to findig the particle that is</span>
<a name="l00060"></a>00060 <span class="comment"> * closest to the vector; for the radical tessellation containers, this</span>
<a name="l00061"></a>00061 <span class="comment"> * corresponds to a finding the minimum weighted distance.</span>
<a name="l00062"></a>00062 <span class="comment"> * \param[in] (x,y,z) the vector to consider.</span>
<a name="l00063"></a>00063 <span class="comment"> * \param[in] (ci,cj,ck) the coordinates of the block that the test particle is</span>
<a name="l00064"></a>00064 <span class="comment"> *                       in relative to the container data structure.</span>
<a name="l00065"></a>00065 <span class="comment"> * \param[in] ijk the index of the block that the test particle is in.</span>
<a name="l00066"></a>00066 <span class="comment"> * \param[out] w a reference to a particle record in which to store information</span>
<a name="l00067"></a>00067 <span class="comment"> *               about the particle whose Voronoi cell the vector is within.</span>
<a name="l00068"></a>00068 <span class="comment"> * \param[out] mrs the minimum computed distance. */</span>
<a name="l00069"></a>00069 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00070"></a><a class="code" href="classvoro_1_1voro__compute.html#aa0b01474a0cf0b230b736e7352404d8d">00070</a> <span class="keywordtype">void</span> <a class="code" href="classvoro_1_1voro__compute.html#aa0b01474a0cf0b230b736e7352404d8d">voro_compute&lt;c_class&gt;::find_voronoi_cell</a>(<span class="keywordtype">double</span> x,<span class="keywordtype">double</span> y,<span class="keywordtype">double</span> z,<span class="keywordtype">int</span> ci,<span class="keywordtype">int</span> cj,<span class="keywordtype">int</span> ck,<span class="keywordtype">int</span> ijk,<a class="code" href="structvoro_1_1particle__record.html" title="Structure for holding information about a particle.">particle_record</a> &amp;w,<span class="keywordtype">double</span> &amp;mrs) {
<a name="l00071"></a>00071         <span class="keywordtype">double</span> qx=0,qy=0,qz=0,rs;
<a name="l00072"></a>00072         <span class="keywordtype">int</span> i,j,k,di,dj,dk,ei,ej,ek,f,g,disp;
<a name="l00073"></a>00073         <span class="keywordtype">double</span> fx,fy,fz,mxs,mys,mzs,*radp;
<a name="l00074"></a>00074         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> q,*e,*mijk;
<a name="l00075"></a>00075 
<a name="l00076"></a>00076         <span class="comment">// Init setup for parameters to return</span>
<a name="l00077"></a>00077         w.<a class="code" href="structvoro_1_1particle__record.html#ac65fa5fc929dda2dd454369eab68ef8b">ijk</a>=-1;mrs=large_number;
<a name="l00078"></a>00078 
<a name="l00079"></a>00079         con.initialize_search(ci,cj,ck,ijk,i,j,k,disp);
<a name="l00080"></a>00080 
<a name="l00081"></a>00081         <span class="comment">// Test all particles in the particle&#39;s local region first</span>
<a name="l00082"></a>00082         scan_all(ijk,x,y,z,0,0,0,w,mrs);
<a name="l00083"></a>00083 
<a name="l00084"></a>00084         <span class="comment">// Now compute the fractional position of the particle within its</span>
<a name="l00085"></a>00085         <span class="comment">// region and store it in (fx,fy,fz). We use this to compute an index</span>
<a name="l00086"></a>00086         <span class="comment">// (di,dj,dk) of which subregion the particle is within.</span>
<a name="l00087"></a>00087         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> m1,m2;
<a name="l00088"></a>00088         con.frac_pos(x,y,z,ci,cj,ck,fx,fy,fz);
<a name="l00089"></a>00089         di=int(fx*xsp*wl_fgrid);dj=int(fy*ysp*wl_fgrid);dk=int(fz*zsp*wl_fgrid);
<a name="l00090"></a>00090 
<a name="l00091"></a>00091         <span class="comment">// The indices (di,dj,dk) tell us which worklist to use, to test the</span>
<a name="l00092"></a>00092         <span class="comment">// blocks in the optimal order. But we only store worklists for the</span>
<a name="l00093"></a>00093         <span class="comment">// eighth of the region where di, dj, and dk are all less than half the</span>
<a name="l00094"></a>00094         <span class="comment">// full grid. The rest of the cases are handled by symmetry. In this</span>
<a name="l00095"></a>00095         <span class="comment">// section, we detect for these cases, by reflecting high values of di,</span>
<a name="l00096"></a>00096         <span class="comment">// dj, and dk. For these cases, a mask is constructed in m1 and m2</span>
<a name="l00097"></a>00097         <span class="comment">// which is used to flip the worklist information when it is loaded.</span>
<a name="l00098"></a>00098         <span class="keywordflow">if</span>(di&gt;=wl_hgrid) {
<a name="l00099"></a>00099                 mxs=boxx-fx;
<a name="l00100"></a>00100                 m1=127+(3&lt;&lt;21);m2=1+(1&lt;&lt;21);di=wl_fgrid-1-di;<span class="keywordflow">if</span>(di&lt;0) di=0;
<a name="l00101"></a>00101         } <span class="keywordflow">else</span> {m1=m2=0;mxs=fx;}
<a name="l00102"></a>00102         <span class="keywordflow">if</span>(dj&gt;=wl_hgrid) {
<a name="l00103"></a>00103                 mys=boxy-fy;
<a name="l00104"></a>00104                 m1|=(127&lt;&lt;7)+(3&lt;&lt;24);m2|=(1&lt;&lt;7)+(1&lt;&lt;24);dj=wl_fgrid-1-dj;<span class="keywordflow">if</span>(dj&lt;0) dj=0;
<a name="l00105"></a>00105         } <span class="keywordflow">else</span> mys=fy;
<a name="l00106"></a>00106         <span class="keywordflow">if</span>(dk&gt;=wl_hgrid) {
<a name="l00107"></a>00107                 mzs=boxz-fz;
<a name="l00108"></a>00108                 m1|=(127&lt;&lt;14)+(3&lt;&lt;27);m2|=(1&lt;&lt;14)+(1&lt;&lt;27);dk=wl_fgrid-1-dk;<span class="keywordflow">if</span>(dk&lt;0) dk=0;
<a name="l00109"></a>00109         } <span class="keywordflow">else</span> mzs=fz;
<a name="l00110"></a>00110 
<a name="l00111"></a>00111         <span class="comment">// Do a quick test to account for the case when the minimum radius is</span>
<a name="l00112"></a>00112         <span class="comment">// small enought that no other blocks need to be considered</span>
<a name="l00113"></a>00113         rs=con.r_max_add(mrs);
<a name="l00114"></a>00114         <span class="keywordflow">if</span>(mxs*mxs&gt;rs&amp;&amp;mys*mys&gt;rs&amp;&amp;mzs*mzs&gt;rs) <span class="keywordflow">return</span>;
<a name="l00115"></a>00115 
<a name="l00116"></a>00116         <span class="comment">// Now compute which worklist we are going to use, and set radp and e to</span>
<a name="l00117"></a>00117         <span class="comment">// point at the right offsets</span>
<a name="l00118"></a>00118         ijk=di+wl_hgrid*(dj+wl_hgrid*dk);
<a name="l00119"></a>00119         radp=mrad+ijk*wl_seq_length;
<a name="l00120"></a>00120         e=(<span class="keyword">const_cast&lt;</span><span class="keywordtype">unsigned</span> <span class="keywordtype">int</span>*<span class="keyword">&gt;</span> (wl))+ijk*wl_seq_length;
<a name="l00121"></a>00121 
<a name="l00122"></a>00122         <span class="comment">// Read in how many items in the worklist can be tested without having to</span>
<a name="l00123"></a>00123         <span class="comment">// worry about writing to the mask</span>
<a name="l00124"></a>00124         f=e[0];g=0;
<a name="l00125"></a>00125         <span class="keywordflow">do</span> {
<a name="l00126"></a>00126 
<a name="l00127"></a>00127                 <span class="comment">// If mrs is less than the minimum distance to any untested</span>
<a name="l00128"></a>00128                 <span class="comment">// block, then we are done</span>
<a name="l00129"></a>00129                 <span class="keywordflow">if</span>(con.r_max_add(mrs)&lt;radp[g]) <span class="keywordflow">return</span>;
<a name="l00130"></a>00130                 g++;
<a name="l00131"></a>00131 
<a name="l00132"></a>00132                 <span class="comment">// Load in a block off the worklist, permute it with the</span>
<a name="l00133"></a>00133                 <span class="comment">// symmetry mask, and decode its position. These are all</span>
<a name="l00134"></a>00134                 <span class="comment">// integer bit operations so they should run very fast.</span>
<a name="l00135"></a>00135                 q=e[g];q^=m1;q+=m2;
<a name="l00136"></a>00136                 di=q&amp;127;di-=64;
<a name="l00137"></a>00137                 dj=(q&gt;&gt;7)&amp;127;dj-=64;
<a name="l00138"></a>00138                 dk=(q&gt;&gt;14)&amp;127;dk-=64;
<a name="l00139"></a>00139 
<a name="l00140"></a>00140                 <span class="comment">// Check that the worklist position is in range</span>
<a name="l00141"></a>00141                 ei=di+i;<span class="keywordflow">if</span>(ei&lt;0||ei&gt;=hx) <span class="keywordflow">continue</span>;
<a name="l00142"></a>00142                 ej=dj+j;<span class="keywordflow">if</span>(ej&lt;0||ej&gt;=hy) <span class="keywordflow">continue</span>;
<a name="l00143"></a>00143                 ek=dk+k;<span class="keywordflow">if</span>(ek&lt;0||ek&gt;=hz) <span class="keywordflow">continue</span>;
<a name="l00144"></a>00144 
<a name="l00145"></a>00145                 <span class="comment">// Call the compute_min_max_radius() function. This returns</span>
<a name="l00146"></a>00146                 <span class="comment">// true if the minimum distance to the block is bigger than the</span>
<a name="l00147"></a>00147                 <span class="comment">// current mrs, in which case we skip this block and move on.</span>
<a name="l00148"></a>00148                 <span class="comment">// Otherwise, it computes the maximum distance to the block and</span>
<a name="l00149"></a>00149                 <span class="comment">// returns it in crs.</span>
<a name="l00150"></a>00150                 <span class="keywordflow">if</span>(compute_min_radius(di,dj,dk,fx,fy,fz,mrs)) <span class="keywordflow">continue</span>;
<a name="l00151"></a>00151 
<a name="l00152"></a>00152                 <span class="comment">// Now compute which region we are going to loop over, adding a</span>
<a name="l00153"></a>00153                 <span class="comment">// displacement for the periodic cases</span>
<a name="l00154"></a>00154                 ijk=con.region_index(ci,cj,ck,ei,ej,ek,qx,qy,qz,disp);
<a name="l00155"></a>00155 
<a name="l00156"></a>00156                 <span class="comment">// If mrs is bigger than the maximum distance to the block,</span>
<a name="l00157"></a>00157                 <span class="comment">// then we have to test all particles in the block for</span>
<a name="l00158"></a>00158                 <span class="comment">// intersections. Otherwise, we do additional checks and skip</span>
<a name="l00159"></a>00159                 <span class="comment">// those particles which can&#39;t possibly intersect the block.</span>
<a name="l00160"></a>00160                 scan_all(ijk,x-qx,y-qy,z-qz,di,dj,dk,w,mrs);
<a name="l00161"></a>00161         } <span class="keywordflow">while</span>(g&lt;f);
<a name="l00162"></a>00162 
<a name="l00163"></a>00163         <span class="comment">// Update mask value and initialize queue</span>
<a name="l00164"></a>00164         mv++;
<a name="l00165"></a>00165         <span class="keywordflow">if</span>(mv==0) {reset_mask();mv=1;}
<a name="l00166"></a>00166         <span class="keywordtype">int</span> *qu_s=qu,*qu_e=qu;
<a name="l00167"></a>00167 
<a name="l00168"></a>00168         <span class="keywordflow">while</span>(g&lt;wl_seq_length-1) {
<a name="l00169"></a>00169 
<a name="l00170"></a>00170                 <span class="comment">// If mrs is less than the minimum distance to any untested</span>
<a name="l00171"></a>00171                 <span class="comment">// block, then we are done</span>
<a name="l00172"></a>00172                 <span class="keywordflow">if</span>(con.r_max_add(mrs)&lt;radp[g]) <span class="keywordflow">return</span>;
<a name="l00173"></a>00173                 g++;
<a name="l00174"></a>00174 
<a name="l00175"></a>00175                 <span class="comment">// Load in a block off the worklist, permute it with the</span>
<a name="l00176"></a>00176                 <span class="comment">// symmetry mask, and decode its position. These are all</span>
<a name="l00177"></a>00177                 <span class="comment">// integer bit operations so they should run very fast.</span>
<a name="l00178"></a>00178                 q=e[g];q^=m1;q+=m2;
<a name="l00179"></a>00179                 di=q&amp;127;di-=64;
<a name="l00180"></a>00180                 dj=(q&gt;&gt;7)&amp;127;dj-=64;
<a name="l00181"></a>00181                 dk=(q&gt;&gt;14)&amp;127;dk-=64;
<a name="l00182"></a>00182 
<a name="l00183"></a>00183                 <span class="comment">// Compute the position in the mask of the current block. If</span>
<a name="l00184"></a>00184                 <span class="comment">// this lies outside the mask, then skip it. Otherwise, mark</span>
<a name="l00185"></a>00185                 <span class="comment">// it.</span>
<a name="l00186"></a>00186                 ei=di+i;<span class="keywordflow">if</span>(ei&lt;0||ei&gt;=hx) <span class="keywordflow">continue</span>;
<a name="l00187"></a>00187                 ej=dj+j;<span class="keywordflow">if</span>(ej&lt;0||ej&gt;=hy) <span class="keywordflow">continue</span>;
<a name="l00188"></a>00188                 ek=dk+k;<span class="keywordflow">if</span>(ek&lt;0||ek&gt;=hz) <span class="keywordflow">continue</span>;
<a name="l00189"></a>00189                 mijk=mask+ei+hx*(ej+hy*ek);
<a name="l00190"></a>00190                 *mijk=mv;
<a name="l00191"></a>00191 
<a name="l00192"></a>00192                 <span class="comment">// Skip this block if it is further away than the current</span>
<a name="l00193"></a>00193                 <span class="comment">// minimum radius</span>
<a name="l00194"></a>00194                 <span class="keywordflow">if</span>(compute_min_radius(di,dj,dk,fx,fy,fz,mrs)) <span class="keywordflow">continue</span>;
<a name="l00195"></a>00195 
<a name="l00196"></a>00196                 <span class="comment">// Now compute which region we are going to loop over, adding a</span>
<a name="l00197"></a>00197                 <span class="comment">// displacement for the periodic cases</span>
<a name="l00198"></a>00198                 ijk=con.region_index(ci,cj,ck,ei,ej,ek,qx,qy,qz,disp);
<a name="l00199"></a>00199                 scan_all(ijk,x-qx,y-qy,z-qz,di,dj,dk,w,mrs);
<a name="l00200"></a>00200 
<a name="l00201"></a>00201                 <span class="keywordflow">if</span>(qu_e&gt;qu_l-18) add_list_memory(qu_s,qu_e);
<a name="l00202"></a>00202                 scan_bits_mask_add(q,mijk,ei,ej,ek,qu_e);
<a name="l00203"></a>00203         }
<a name="l00204"></a>00204 
<a name="l00205"></a>00205         <span class="comment">// Do a check to see if we&#39;ve reached the radius cutoff</span>
<a name="l00206"></a>00206         <span class="keywordflow">if</span>(con.r_max_add(mrs)&lt;radp[g]) <span class="keywordflow">return</span>;
<a name="l00207"></a>00207 
<a name="l00208"></a>00208         <span class="comment">// We were unable to completely compute the cell based on the blocks in</span>
<a name="l00209"></a>00209         <span class="comment">// the worklist, so now we have to go block by block, reading in items</span>
<a name="l00210"></a>00210         <span class="comment">// off the list</span>
<a name="l00211"></a>00211         <span class="keywordflow">while</span>(qu_s!=qu_e) {
<a name="l00212"></a>00212 
<a name="l00213"></a>00213                 <span class="comment">// Read the next entry of the queue</span>
<a name="l00214"></a>00214                 <span class="keywordflow">if</span>(qu_s==qu_l) qu_s=qu;
<a name="l00215"></a>00215                 ei=*(qu_s++);ej=*(qu_s++);ek=*(qu_s++);
<a name="l00216"></a>00216                 di=ei-i;dj=ej-j;dk=ek-k;
<a name="l00217"></a>00217                 <span class="keywordflow">if</span>(compute_min_radius(di,dj,dk,fx,fy,fz,mrs)) <span class="keywordflow">continue</span>;
<a name="l00218"></a>00218 
<a name="l00219"></a>00219                 ijk=con.region_index(ci,cj,ck,ei,ej,ek,qx,qy,qz,disp);
<a name="l00220"></a>00220                 scan_all(ijk,x-qx,y-qy,z-qz,di,dj,dk,w,mrs);
<a name="l00221"></a>00221 
<a name="l00222"></a>00222                 <span class="comment">// Test the neighbors of the current block, and add them to the</span>
<a name="l00223"></a>00223                 <span class="comment">// block list if they haven&#39;t already been tested</span>
<a name="l00224"></a>00224                 <span class="keywordflow">if</span>((qu_s&lt;=qu_e?(qu_l-qu_e)+(qu_s-qu):qu_s-qu_e)&lt;18) add_list_memory(qu_s,qu_e);
<a name="l00225"></a>00225                 add_to_mask(ei,ej,ek,qu_e);
<a name="l00226"></a>00226         }
<a name="l00227"></a>00227 }
<a name="l00228"></a>00228 <span class="comment"></span>
<a name="l00229"></a>00229 <span class="comment">/** Scans the six orthogonal neighbors of a given block and adds them to the</span>
<a name="l00230"></a>00230 <span class="comment"> * queue if they haven&#39;t been considered already. It assumes that the queue</span>
<a name="l00231"></a>00231 <span class="comment"> * will definitely have enough memory to add six entries at the end.</span>
<a name="l00232"></a>00232 <span class="comment"> * \param[in] (ei,ej,ek) the block to consider.</span>
<a name="l00233"></a>00233 <span class="comment"> * \param[in,out] qu_e a pointer to the end of the queue. */</span>
<a name="l00234"></a>00234 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00235"></a>00235 <span class="keyword">inline</span> <span class="keywordtype">void</span> <a class="code" href="classvoro_1_1voro__compute.html" title="Template for carrying out Voronoi cell computations.">voro_compute&lt;c_class&gt;::add_to_mask</a>(<span class="keywordtype">int</span> ei,<span class="keywordtype">int</span> ej,<span class="keywordtype">int</span> ek,<span class="keywordtype">int</span> *&amp;qu_e) {
<a name="l00236"></a>00236         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> *mijk=mask+ei+hx*(ej+hy*ek);
<a name="l00237"></a>00237         <span class="keywordflow">if</span>(ek&gt;0) <span class="keywordflow">if</span>(*(mijk-hxy)!=mv) {<span class="keywordflow">if</span>(qu_e==qu_l) qu_e=qu;*(mijk-hxy)=mv;*(qu_e++)=ei;*(qu_e++)=ej;*(qu_e++)=ek-1;}
<a name="l00238"></a>00238         <span class="keywordflow">if</span>(ej&gt;0) <span class="keywordflow">if</span>(*(mijk-hx)!=mv) {<span class="keywordflow">if</span>(qu_e==qu_l) qu_e=qu;*(mijk-hx)=mv;*(qu_e++)=ei;*(qu_e++)=ej-1;*(qu_e++)=ek;}
<a name="l00239"></a>00239         <span class="keywordflow">if</span>(ei&gt;0) <span class="keywordflow">if</span>(*(mijk-1)!=mv) {<span class="keywordflow">if</span>(qu_e==qu_l) qu_e=qu;*(mijk-1)=mv;*(qu_e++)=ei-1;*(qu_e++)=ej;*(qu_e++)=ek;}
<a name="l00240"></a>00240         <span class="keywordflow">if</span>(ei&lt;hx-1) <span class="keywordflow">if</span>(*(mijk+1)!=mv) {<span class="keywordflow">if</span>(qu_e==qu_l) qu_e=qu;*(mijk+1)=mv;*(qu_e++)=ei+1;*(qu_e++)=ej;*(qu_e++)=ek;}
<a name="l00241"></a>00241         <span class="keywordflow">if</span>(ej&lt;hy-1) <span class="keywordflow">if</span>(*(mijk+hx)!=mv) {<span class="keywordflow">if</span>(qu_e==qu_l) qu_e=qu;*(mijk+hx)=mv;*(qu_e++)=ei;*(qu_e++)=ej+1;*(qu_e++)=ek;}
<a name="l00242"></a>00242         <span class="keywordflow">if</span>(ek&lt;hz-1) <span class="keywordflow">if</span>(*(mijk+hxy)!=mv) {<span class="keywordflow">if</span>(qu_e==qu_l) qu_e=qu;*(mijk+hxy)=mv;*(qu_e++)=ei;*(qu_e++)=ej;*(qu_e++)=ek+1;}
<a name="l00243"></a>00243 }
<a name="l00244"></a>00244 <span class="comment"></span>
<a name="l00245"></a>00245 <span class="comment">/** Scans a worklist entry and adds any blocks to the queue</span>
<a name="l00246"></a>00246 <span class="comment"> * \param[in] (ei,ej,ek) the block to consider.</span>
<a name="l00247"></a>00247 <span class="comment"> * \param[in,out] qu_e a pointer to the end of the queue. */</span>
<a name="l00248"></a>00248 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00249"></a>00249 <span class="keyword">inline</span> <span class="keywordtype">void</span> voro_compute&lt;c_class&gt;::scan_bits_mask_add(<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> q,<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> *mijk,<span class="keywordtype">int</span> ei,<span class="keywordtype">int</span> ej,<span class="keywordtype">int</span> ek,<span class="keywordtype">int</span> *&amp;qu_e) {
<a name="l00250"></a>00250         <span class="keyword">const</span> <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> b1=1&lt;&lt;21,b2=1&lt;&lt;22,b3=1&lt;&lt;24,b4=1&lt;&lt;25,b5=1&lt;&lt;27,b6=1&lt;&lt;28;
<a name="l00251"></a>00251         <span class="keywordflow">if</span>((q&amp;b2)==b2) {
<a name="l00252"></a>00252                 <span class="keywordflow">if</span>(ei&gt;0) {*(mijk-1)=mv;*(qu_e++)=ei-1;*(qu_e++)=ej;*(qu_e++)=ek;}
<a name="l00253"></a>00253                 <span class="keywordflow">if</span>((q&amp;b1)==0&amp;&amp;ei&lt;hx-1) {*(mijk+1)=mv;*(qu_e++)=ei+1;*(qu_e++)=ej;*(qu_e++)=ek;}
<a name="l00254"></a>00254         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>((q&amp;b1)==b1&amp;&amp;ei&lt;hx-1) {*(mijk+1)=mv;*(qu_e++)=ei+1;*(qu_e++)=ej;*(qu_e++)=ek;}
<a name="l00255"></a>00255         <span class="keywordflow">if</span>((q&amp;b4)==b4) {
<a name="l00256"></a>00256                 <span class="keywordflow">if</span>(ej&gt;0) {*(mijk-hx)=mv;*(qu_e++)=ei;*(qu_e++)=ej-1;*(qu_e++)=ek;}
<a name="l00257"></a>00257                 <span class="keywordflow">if</span>((q&amp;b3)==0&amp;&amp;ej&lt;hy-1) {*(mijk+hx)=mv;*(qu_e++)=ei;*(qu_e++)=ej+1;*(qu_e++)=ek;}
<a name="l00258"></a>00258         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>((q&amp;b3)==b3&amp;&amp;ej&lt;hy-1) {*(mijk+hx)=mv;*(qu_e++)=ei;*(qu_e++)=ej+1;*(qu_e++)=ek;}
<a name="l00259"></a>00259         <span class="keywordflow">if</span>((q&amp;b6)==b6) {
<a name="l00260"></a>00260                 <span class="keywordflow">if</span>(ek&gt;0) {*(mijk-hxy)=mv;*(qu_e++)=ei;*(qu_e++)=ej;*(qu_e++)=ek-1;}
<a name="l00261"></a>00261                 <span class="keywordflow">if</span>((q&amp;b5)==0&amp;&amp;ek&lt;hz-1) {*(mijk+hxy)=mv;*(qu_e++)=ei;*(qu_e++)=ej;*(qu_e++)=ek+1;}
<a name="l00262"></a>00262         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>((q&amp;b5)==b5&amp;&amp;ek&lt;hz-1) {*(mijk+hxy)=mv;*(qu_e++)=ei;*(qu_e++)=ej;*(qu_e++)=ek+1;}
<a name="l00263"></a>00263 }
<a name="l00264"></a>00264 <span class="comment"></span>
<a name="l00265"></a>00265 <span class="comment">/** This routine computes a Voronoi cell for a single particle in the</span>
<a name="l00266"></a>00266 <span class="comment"> * container. It can be called by the user, but is also forms the core part of</span>
<a name="l00267"></a>00267 <span class="comment"> * several of the main functions, such as store_cell_volumes(), print_all(),</span>
<a name="l00268"></a>00268 <span class="comment"> * and the drawing routines. The algorithm constructs the cell by testing over</span>
<a name="l00269"></a>00269 <span class="comment"> * the neighbors of the particle, working outwards until it reaches those</span>
<a name="l00270"></a>00270 <span class="comment"> * particles which could not possibly intersect the cell. For maximum</span>
<a name="l00271"></a>00271 <span class="comment"> * efficiency, this algorithm is divided into three parts. In the first</span>
<a name="l00272"></a>00272 <span class="comment"> * section, the algorithm tests over the blocks which are in the immediate</span>
<a name="l00273"></a>00273 <span class="comment"> * vicinity of the particle, by making use of one of the precomputed worklists.</span>
<a name="l00274"></a>00274 <span class="comment"> * The code then continues to test blocks on the worklist, but also begins to</span>
<a name="l00275"></a>00275 <span class="comment"> * construct a list of neighboring blocks outside the worklist which may need</span>
<a name="l00276"></a>00276 <span class="comment"> * to be test. In the third section, the routine starts testing these</span>
<a name="l00277"></a>00277 <span class="comment"> * neighboring blocks, evaluating whether or not a particle in them could</span>
<a name="l00278"></a>00278 <span class="comment"> * possibly intersect the cell. For blocks that intersect the cell, it tests</span>
<a name="l00279"></a>00279 <span class="comment"> * the particles in that block, and then adds the block neighbors to the list</span>
<a name="l00280"></a>00280 <span class="comment"> * of potential places to consider.</span>
<a name="l00281"></a>00281 <span class="comment"> * \param[in,out] c a reference to a voronoicell object.</span>
<a name="l00282"></a>00282 <span class="comment"> * \param[in] ijk the index of the block that the test particle is in.</span>
<a name="l00283"></a>00283 <span class="comment"> * \param[in] s the index of the particle within the test block.</span>
<a name="l00284"></a>00284 <span class="comment"> * \param[in] (ci,cj,ck) the coordinates of the block that the test particle is</span>
<a name="l00285"></a>00285 <span class="comment"> *                       in relative to the container data structure.</span>
<a name="l00286"></a>00286 <span class="comment"> * \return False if the Voronoi cell was completely removed during the</span>
<a name="l00287"></a>00287 <span class="comment"> *         computation and has zero volume, true otherwise. */</span>
<a name="l00288"></a>00288 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00289"></a>00289 <span class="keyword">template</span>&lt;<span class="keyword">class</span> v_cell&gt;
<a name="l00290"></a><a class="code" href="classvoro_1_1voro__compute.html#a09ac0d2470ba4f62482d0cfed4eafbc0">00290</a> <span class="keywordtype">bool</span> <a class="code" href="classvoro_1_1voro__compute.html#a09ac0d2470ba4f62482d0cfed4eafbc0">voro_compute&lt;c_class&gt;::compute_cell</a>(v_cell &amp;c,<span class="keywordtype">int</span> ijk,<span class="keywordtype">int</span> s,<span class="keywordtype">int</span> ci,<span class="keywordtype">int</span> cj,<span class="keywordtype">int</span> ck) {
<a name="l00291"></a>00291         <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">int</span> count_list[8]={7,11,15,19,26,35,45,59},*count_e=count_list+8;
<a name="l00292"></a>00292         <span class="keywordtype">double</span> x,y,z,x1,y1,z1,qx=0,qy=0,qz=0;
<a name="l00293"></a>00293         <span class="keywordtype">double</span> xlo,ylo,zlo,xhi,yhi,zhi,x2,y2,z2,rs;
<a name="l00294"></a>00294         <span class="keywordtype">int</span> i,j,k,di,dj,dk,ei,ej,ek,f,g,l,disp;
<a name="l00295"></a>00295         <span class="keywordtype">double</span> fx,fy,fz,gxs,gys,gzs,*radp;
<a name="l00296"></a>00296         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> q,*e,*mijk;
<a name="l00297"></a>00297 
<a name="l00298"></a>00298         <span class="keywordflow">if</span>(!con.initialize_voronoicell(c,ijk,s,ci,cj,ck,i,j,k,x,y,z,disp)) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00299"></a>00299         con.r_init(ijk,s);
<a name="l00300"></a>00300 
<a name="l00301"></a>00301         <span class="comment">// Initialize the Voronoi cell to fill the entire container</span>
<a name="l00302"></a>00302         <span class="keywordtype">double</span> crs,mrs;
<a name="l00303"></a>00303 
<a name="l00304"></a>00304         <span class="keywordtype">int</span> next_count=3,*count_p=(<span class="keyword">const_cast&lt;</span><span class="keywordtype">int</span>*<span class="keyword">&gt;</span> (count_list));
<a name="l00305"></a>00305 
<a name="l00306"></a>00306         <span class="comment">// Test all particles in the particle&#39;s local region first</span>
<a name="l00307"></a>00307         <span class="keywordflow">for</span>(l=0;l&lt;s;l++) {
<a name="l00308"></a>00308                 x1=p[ijk][ps*l]-x;
<a name="l00309"></a>00309                 y1=p[ijk][ps*l+1]-y;
<a name="l00310"></a>00310                 z1=p[ijk][ps*l+2]-z;
<a name="l00311"></a>00311                 rs=con.r_scale(x1*x1+y1*y1+z1*z1,ijk,l);
<a name="l00312"></a>00312                 <span class="keywordflow">if</span>(!c.nplane(x1,y1,z1,rs,<span class="keywordtype">id</span>[ijk][l])) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00313"></a>00313         }
<a name="l00314"></a>00314         l++;
<a name="l00315"></a>00315         <span class="keywordflow">while</span>(l&lt;co[ijk]) {
<a name="l00316"></a>00316                 x1=p[ijk][ps*l]-x;
<a name="l00317"></a>00317                 y1=p[ijk][ps*l+1]-y;
<a name="l00318"></a>00318                 z1=p[ijk][ps*l+2]-z;
<a name="l00319"></a>00319                 rs=con.r_scale(x1*x1+y1*y1+z1*z1,ijk,l);
<a name="l00320"></a>00320                 <span class="keywordflow">if</span>(!c.nplane(x1,y1,z1,rs,<span class="keywordtype">id</span>[ijk][l])) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00321"></a>00321                 l++;
<a name="l00322"></a>00322         }
<a name="l00323"></a>00323 
<a name="l00324"></a>00324         <span class="comment">// Now compute the maximum distance squared from the cell center to a</span>
<a name="l00325"></a>00325         <span class="comment">// vertex. This is used to cut off the calculation since we only need</span>
<a name="l00326"></a>00326         <span class="comment">// to test out to twice this range.</span>
<a name="l00327"></a>00327         mrs=c.max_radius_squared();
<a name="l00328"></a>00328 
<a name="l00329"></a>00329         <span class="comment">// Now compute the fractional position of the particle within its</span>
<a name="l00330"></a>00330         <span class="comment">// region and store it in (fx,fy,fz). We use this to compute an index</span>
<a name="l00331"></a>00331         <span class="comment">// (di,dj,dk) of which subregion the particle is within.</span>
<a name="l00332"></a>00332         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> m1,m2;
<a name="l00333"></a>00333         con.frac_pos(x,y,z,ci,cj,ck,fx,fy,fz);
<a name="l00334"></a>00334         di=int(fx*xsp*wl_fgrid);dj=int(fy*ysp*wl_fgrid);dk=int(fz*zsp*wl_fgrid);
<a name="l00335"></a>00335 
<a name="l00336"></a>00336         <span class="comment">// The indices (di,dj,dk) tell us which worklist to use, to test the</span>
<a name="l00337"></a>00337         <span class="comment">// blocks in the optimal order. But we only store worklists for the</span>
<a name="l00338"></a>00338         <span class="comment">// eighth of the region where di, dj, and dk are all less than half the</span>
<a name="l00339"></a>00339         <span class="comment">// full grid. The rest of the cases are handled by symmetry. In this</span>
<a name="l00340"></a>00340         <span class="comment">// section, we detect for these cases, by reflecting high values of di,</span>
<a name="l00341"></a>00341         <span class="comment">// dj, and dk. For these cases, a mask is constructed in m1 and m2</span>
<a name="l00342"></a>00342         <span class="comment">// which is used to flip the worklist information when it is loaded.</span>
<a name="l00343"></a>00343         <span class="keywordflow">if</span>(di&gt;=wl_hgrid) {
<a name="l00344"></a>00344                 gxs=fx;
<a name="l00345"></a>00345                 m1=127+(3&lt;&lt;21);m2=1+(1&lt;&lt;21);di=wl_fgrid-1-di;<span class="keywordflow">if</span>(di&lt;0) di=0;
<a name="l00346"></a>00346         } <span class="keywordflow">else</span> {m1=m2=0;gxs=boxx-fx;}
<a name="l00347"></a>00347         <span class="keywordflow">if</span>(dj&gt;=wl_hgrid) {
<a name="l00348"></a>00348                 gys=fy;
<a name="l00349"></a>00349                 m1|=(127&lt;&lt;7)+(3&lt;&lt;24);m2|=(1&lt;&lt;7)+(1&lt;&lt;24);dj=wl_fgrid-1-dj;<span class="keywordflow">if</span>(dj&lt;0) dj=0;
<a name="l00350"></a>00350         } <span class="keywordflow">else</span> gys=boxy-fy;
<a name="l00351"></a>00351         <span class="keywordflow">if</span>(dk&gt;=wl_hgrid) {
<a name="l00352"></a>00352                 gzs=fz;
<a name="l00353"></a>00353                 m1|=(127&lt;&lt;14)+(3&lt;&lt;27);m2|=(1&lt;&lt;14)+(1&lt;&lt;27);dk=wl_fgrid-1-dk;<span class="keywordflow">if</span>(dk&lt;0) dk=0;
<a name="l00354"></a>00354         } <span class="keywordflow">else</span> gzs=boxz-fz;
<a name="l00355"></a>00355         gxs*=gxs;gys*=gys;gzs*=gzs;
<a name="l00356"></a>00356 
<a name="l00357"></a>00357         <span class="comment">// Now compute which worklist we are going to use, and set radp and e to</span>
<a name="l00358"></a>00358         <span class="comment">// point at the right offsets</span>
<a name="l00359"></a>00359         ijk=di+wl_hgrid*(dj+wl_hgrid*dk);
<a name="l00360"></a>00360         radp=mrad+ijk*wl_seq_length;
<a name="l00361"></a>00361         e=(<span class="keyword">const_cast&lt;</span><span class="keywordtype">unsigned</span> <span class="keywordtype">int</span>*<span class="keyword">&gt;</span> (wl))+ijk*wl_seq_length;
<a name="l00362"></a>00362 
<a name="l00363"></a>00363         <span class="comment">// Read in how many items in the worklist can be tested without having to</span>
<a name="l00364"></a>00364         <span class="comment">// worry about writing to the mask</span>
<a name="l00365"></a>00365         f=e[0];g=0;
<a name="l00366"></a>00366         <span class="keywordflow">do</span> {
<a name="l00367"></a>00367 
<a name="l00368"></a>00368                 <span class="comment">// At the intervals specified by count_list, we recompute the</span>
<a name="l00369"></a>00369                 <span class="comment">// maximum radius squared</span>
<a name="l00370"></a>00370                 <span class="keywordflow">if</span>(g==next_count) {
<a name="l00371"></a>00371                         mrs=c.max_radius_squared();
<a name="l00372"></a>00372                         <span class="keywordflow">if</span>(count_p!=count_e) next_count=*(count_p++);
<a name="l00373"></a>00373                 }
<a name="l00374"></a>00374 
<a name="l00375"></a>00375                 <span class="comment">// If mrs is less than the minimum distance to any untested</span>
<a name="l00376"></a>00376                 <span class="comment">// block, then we are done</span>
<a name="l00377"></a>00377                 <span class="keywordflow">if</span>(con.r_ctest(radp[g],mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00378"></a>00378                 g++;
<a name="l00379"></a>00379 
<a name="l00380"></a>00380                 <span class="comment">// Load in a block off the worklist, permute it with the</span>
<a name="l00381"></a>00381                 <span class="comment">// symmetry mask, and decode its position. These are all</span>
<a name="l00382"></a>00382                 <span class="comment">// integer bit operations so they should run very fast.</span>
<a name="l00383"></a>00383                 q=e[g];q^=m1;q+=m2;
<a name="l00384"></a>00384                 di=q&amp;127;di-=64;
<a name="l00385"></a>00385                 dj=(q&gt;&gt;7)&amp;127;dj-=64;
<a name="l00386"></a>00386                 dk=(q&gt;&gt;14)&amp;127;dk-=64;
<a name="l00387"></a>00387 
<a name="l00388"></a>00388                 <span class="comment">// Check that the worklist position is in range</span>
<a name="l00389"></a>00389                 ei=di+i;<span class="keywordflow">if</span>(ei&lt;0||ei&gt;=hx) <span class="keywordflow">continue</span>;
<a name="l00390"></a>00390                 ej=dj+j;<span class="keywordflow">if</span>(ej&lt;0||ej&gt;=hy) <span class="keywordflow">continue</span>;
<a name="l00391"></a>00391                 ek=dk+k;<span class="keywordflow">if</span>(ek&lt;0||ek&gt;=hz) <span class="keywordflow">continue</span>;
<a name="l00392"></a>00392 
<a name="l00393"></a>00393                 <span class="comment">// Call the compute_min_max_radius() function. This returns</span>
<a name="l00394"></a>00394                 <span class="comment">// true if the minimum distance to the block is bigger than the</span>
<a name="l00395"></a>00395                 <span class="comment">// current mrs, in which case we skip this block and move on.</span>
<a name="l00396"></a>00396                 <span class="comment">// Otherwise, it computes the maximum distance to the block and</span>
<a name="l00397"></a>00397                 <span class="comment">// returns it in crs.</span>
<a name="l00398"></a>00398                 <span class="keywordflow">if</span>(compute_min_max_radius(di,dj,dk,fx,fy,fz,gxs,gys,gzs,crs,mrs)) <span class="keywordflow">continue</span>;
<a name="l00399"></a>00399 
<a name="l00400"></a>00400                 <span class="comment">// Now compute which region we are going to loop over, adding a</span>
<a name="l00401"></a>00401                 <span class="comment">// displacement for the periodic cases</span>
<a name="l00402"></a>00402                 ijk=con.region_index(ci,cj,ck,ei,ej,ek,qx,qy,qz,disp);
<a name="l00403"></a>00403 
<a name="l00404"></a>00404                 <span class="comment">// If mrs is bigger than the maximum distance to the block,</span>
<a name="l00405"></a>00405                 <span class="comment">// then we have to test all particles in the block for</span>
<a name="l00406"></a>00406                 <span class="comment">// intersections. Otherwise, we do additional checks and skip</span>
<a name="l00407"></a>00407                 <span class="comment">// those particles which can&#39;t possibly intersect the block.</span>
<a name="l00408"></a>00408                 <span class="keywordflow">if</span>(co[ijk]&gt;0) {
<a name="l00409"></a>00409                         l=0;x2=x-qx;y2=y-qy;z2=z-qz;
<a name="l00410"></a>00410                         <span class="keywordflow">if</span>(!con.r_ctest(crs,mrs)) {
<a name="l00411"></a>00411                                 <span class="keywordflow">do</span> {
<a name="l00412"></a>00412                                         x1=p[ijk][ps*l]-x2;
<a name="l00413"></a>00413                                         y1=p[ijk][ps*l+1]-y2;
<a name="l00414"></a>00414                                         z1=p[ijk][ps*l+2]-z2;
<a name="l00415"></a>00415                                         rs=con.r_scale(x1*x1+y1*y1+z1*z1,ijk,l);
<a name="l00416"></a>00416                                         <span class="keywordflow">if</span>(!c.nplane(x1,y1,z1,rs,<span class="keywordtype">id</span>[ijk][l])) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00417"></a>00417                                         l++;
<a name="l00418"></a>00418                                 } <span class="keywordflow">while</span> (l&lt;co[ijk]);
<a name="l00419"></a>00419                         } <span class="keywordflow">else</span> {
<a name="l00420"></a>00420                                 <span class="keywordflow">do</span> {
<a name="l00421"></a>00421                                         x1=p[ijk][ps*l]-x2;
<a name="l00422"></a>00422                                         y1=p[ijk][ps*l+1]-y2;
<a name="l00423"></a>00423                                         z1=p[ijk][ps*l+2]-z2;
<a name="l00424"></a>00424                                         rs=x1*x1+y1*y1+z1*z1;
<a name="l00425"></a>00425                                         <span class="keywordflow">if</span>(con.r_scale_check(rs,mrs,ijk,l)&amp;&amp;!c.nplane(x1,y1,z1,rs,<span class="keywordtype">id</span>[ijk][l])) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00426"></a>00426                                         l++;
<a name="l00427"></a>00427                                 } <span class="keywordflow">while</span> (l&lt;co[ijk]);
<a name="l00428"></a>00428                         }
<a name="l00429"></a>00429                 }
<a name="l00430"></a>00430         } <span class="keywordflow">while</span>(g&lt;f);
<a name="l00431"></a>00431 
<a name="l00432"></a>00432         <span class="comment">// If we reach here, we were unable to compute the entire cell using</span>
<a name="l00433"></a>00433         <span class="comment">// the first part of the worklist. This section of the algorithm</span>
<a name="l00434"></a>00434         <span class="comment">// continues the worklist, but it now starts preparing the mask that we</span>
<a name="l00435"></a>00435         <span class="comment">// need if we end up going block by block. We do the same as before,</span>
<a name="l00436"></a>00436         <span class="comment">// but we put a mark down on the mask for every block that&#39;s tested.</span>
<a name="l00437"></a>00437         <span class="comment">// The worklist also contains information about which neighbors of each</span>
<a name="l00438"></a>00438         <span class="comment">// block are not also on the worklist, and we start storing those</span>
<a name="l00439"></a>00439         <span class="comment">// points in a list in case we have to go block by block. Update the</span>
<a name="l00440"></a>00440         <span class="comment">// mask counter, and if it wraps around then reset the whole mask; that</span>
<a name="l00441"></a>00441         <span class="comment">// will only happen once every 2^32 tries.</span>
<a name="l00442"></a>00442         mv++;
<a name="l00443"></a>00443         <span class="keywordflow">if</span>(mv==0) {reset_mask();mv=1;}
<a name="l00444"></a>00444 
<a name="l00445"></a>00445         <span class="comment">// Set the queue pointers</span>
<a name="l00446"></a>00446         <span class="keywordtype">int</span> *qu_s=qu,*qu_e=qu;
<a name="l00447"></a>00447 
<a name="l00448"></a>00448         <span class="keywordflow">while</span>(g&lt;wl_seq_length-1) {
<a name="l00449"></a>00449 
<a name="l00450"></a>00450                 <span class="comment">// At the intervals specified by count_list, we recompute the</span>
<a name="l00451"></a>00451                 <span class="comment">// maximum radius squared</span>
<a name="l00452"></a>00452                 <span class="keywordflow">if</span>(g==next_count) {
<a name="l00453"></a>00453                         mrs=c.max_radius_squared();
<a name="l00454"></a>00454                         <span class="keywordflow">if</span>(count_p!=count_e) next_count=*(count_p++);
<a name="l00455"></a>00455                 }
<a name="l00456"></a>00456 
<a name="l00457"></a>00457                 <span class="comment">// If mrs is less than the minimum distance to any untested</span>
<a name="l00458"></a>00458                 <span class="comment">// block, then we are done</span>
<a name="l00459"></a>00459                 <span class="keywordflow">if</span>(con.r_ctest(radp[g],mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00460"></a>00460                 g++;
<a name="l00461"></a>00461 
<a name="l00462"></a>00462                 <span class="comment">// Load in a block off the worklist, permute it with the</span>
<a name="l00463"></a>00463                 <span class="comment">// symmetry mask, and decode its position. These are all</span>
<a name="l00464"></a>00464                 <span class="comment">// integer bit operations so they should run very fast.</span>
<a name="l00465"></a>00465                 q=e[g];q^=m1;q+=m2;
<a name="l00466"></a>00466                 di=q&amp;127;di-=64;
<a name="l00467"></a>00467                 dj=(q&gt;&gt;7)&amp;127;dj-=64;
<a name="l00468"></a>00468                 dk=(q&gt;&gt;14)&amp;127;dk-=64;
<a name="l00469"></a>00469 
<a name="l00470"></a>00470                 <span class="comment">// Compute the position in the mask of the current block. If</span>
<a name="l00471"></a>00471                 <span class="comment">// this lies outside the mask, then skip it. Otherwise, mark</span>
<a name="l00472"></a>00472                 <span class="comment">// it.</span>
<a name="l00473"></a>00473                 ei=di+i;<span class="keywordflow">if</span>(ei&lt;0||ei&gt;=hx) <span class="keywordflow">continue</span>;
<a name="l00474"></a>00474                 ej=dj+j;<span class="keywordflow">if</span>(ej&lt;0||ej&gt;=hy) <span class="keywordflow">continue</span>;
<a name="l00475"></a>00475                 ek=dk+k;<span class="keywordflow">if</span>(ek&lt;0||ek&gt;=hz) <span class="keywordflow">continue</span>;
<a name="l00476"></a>00476                 mijk=mask+ei+hx*(ej+hy*ek);
<a name="l00477"></a>00477                 *mijk=mv;
<a name="l00478"></a>00478 
<a name="l00479"></a>00479                 <span class="comment">// Call the compute_min_max_radius() function. This returns</span>
<a name="l00480"></a>00480                 <span class="comment">// true if the minimum distance to the block is bigger than the</span>
<a name="l00481"></a>00481                 <span class="comment">// current mrs, in which case we skip this block and move on.</span>
<a name="l00482"></a>00482                 <span class="comment">// Otherwise, it computes the maximum distance to the block and</span>
<a name="l00483"></a>00483                 <span class="comment">// returns it in crs.</span>
<a name="l00484"></a>00484                 <span class="keywordflow">if</span>(compute_min_max_radius(di,dj,dk,fx,fy,fz,gxs,gys,gzs,crs,mrs)) <span class="keywordflow">continue</span>;
<a name="l00485"></a>00485 
<a name="l00486"></a>00486                 <span class="comment">// Now compute which region we are going to loop over, adding a</span>
<a name="l00487"></a>00487                 <span class="comment">// displacement for the periodic cases</span>
<a name="l00488"></a>00488                 ijk=con.region_index(ci,cj,ck,ei,ej,ek,qx,qy,qz,disp);
<a name="l00489"></a>00489 
<a name="l00490"></a>00490                 <span class="comment">// If mrs is bigger than the maximum distance to the block,</span>
<a name="l00491"></a>00491                 <span class="comment">// then we have to test all particles in the block for</span>
<a name="l00492"></a>00492                 <span class="comment">// intersections. Otherwise, we do additional checks and skip</span>
<a name="l00493"></a>00493                 <span class="comment">// those particles which can&#39;t possibly intersect the block.</span>
<a name="l00494"></a>00494                 <span class="keywordflow">if</span>(co[ijk]&gt;0) {
<a name="l00495"></a>00495                         l=0;x2=x-qx;y2=y-qy;z2=z-qz;
<a name="l00496"></a>00496                         <span class="keywordflow">if</span>(!con.r_ctest(crs,mrs)) {
<a name="l00497"></a>00497                                 <span class="keywordflow">do</span> {
<a name="l00498"></a>00498                                         x1=p[ijk][ps*l]-x2;
<a name="l00499"></a>00499                                         y1=p[ijk][ps*l+1]-y2;
<a name="l00500"></a>00500                                         z1=p[ijk][ps*l+2]-z2;
<a name="l00501"></a>00501                                         rs=con.r_scale(x1*x1+y1*y1+z1*z1,ijk,l);
<a name="l00502"></a>00502                                         <span class="keywordflow">if</span>(!c.nplane(x1,y1,z1,rs,<span class="keywordtype">id</span>[ijk][l])) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00503"></a>00503                                         l++;
<a name="l00504"></a>00504                                 } <span class="keywordflow">while</span> (l&lt;co[ijk]);
<a name="l00505"></a>00505                         } <span class="keywordflow">else</span> {
<a name="l00506"></a>00506                                 <span class="keywordflow">do</span> {
<a name="l00507"></a>00507                                         x1=p[ijk][ps*l]-x2;
<a name="l00508"></a>00508                                         y1=p[ijk][ps*l+1]-y2;
<a name="l00509"></a>00509                                         z1=p[ijk][ps*l+2]-z2;
<a name="l00510"></a>00510                                         rs=x1*x1+y1*y1+z1*z1;
<a name="l00511"></a>00511                                         <span class="keywordflow">if</span>(con.r_scale_check(rs,mrs,ijk,l)&amp;&amp;!c.nplane(x1,y1,z1,rs,<span class="keywordtype">id</span>[ijk][l])) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00512"></a>00512                                         l++;
<a name="l00513"></a>00513                                 } <span class="keywordflow">while</span> (l&lt;co[ijk]);
<a name="l00514"></a>00514                         }
<a name="l00515"></a>00515                 }
<a name="l00516"></a>00516 
<a name="l00517"></a>00517                 <span class="comment">// If there might not be enough memory on the list for these</span>
<a name="l00518"></a>00518                 <span class="comment">// additions, then add more</span>
<a name="l00519"></a>00519                 <span class="keywordflow">if</span>(qu_e&gt;qu_l-18) add_list_memory(qu_s,qu_e);
<a name="l00520"></a>00520 
<a name="l00521"></a>00521                 <span class="comment">// Test the parts of the worklist element which tell us what</span>
<a name="l00522"></a>00522                 <span class="comment">// neighbors of this block are not on the worklist. Store them</span>
<a name="l00523"></a>00523                 <span class="comment">// on the block list, and mark the mask.</span>
<a name="l00524"></a>00524                 scan_bits_mask_add(q,mijk,ei,ej,ek,qu_e);
<a name="l00525"></a>00525         }
<a name="l00526"></a>00526 
<a name="l00527"></a>00527         <span class="comment">// Do a check to see if we&#39;ve reached the radius cutoff</span>
<a name="l00528"></a>00528         <span class="keywordflow">if</span>(con.r_ctest(radp[g],mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00529"></a>00529 
<a name="l00530"></a>00530         <span class="comment">// We were unable to completely compute the cell based on the blocks in</span>
<a name="l00531"></a>00531         <span class="comment">// the worklist, so now we have to go block by block, reading in items</span>
<a name="l00532"></a>00532         <span class="comment">// off the list</span>
<a name="l00533"></a>00533         <span class="keywordflow">while</span>(qu_s!=qu_e) {
<a name="l00534"></a>00534 
<a name="l00535"></a>00535                 <span class="comment">// If we reached the end of the list memory loop back to the</span>
<a name="l00536"></a>00536                 <span class="comment">// start</span>
<a name="l00537"></a>00537                 <span class="keywordflow">if</span>(qu_s==qu_l) qu_s=qu;
<a name="l00538"></a>00538 
<a name="l00539"></a>00539                 <span class="comment">// Read in a block off the list, and compute the upper and lower</span>
<a name="l00540"></a>00540                 <span class="comment">// coordinates in each of the three dimensions</span>
<a name="l00541"></a>00541                 ei=*(qu_s++);ej=*(qu_s++);ek=*(qu_s++);
<a name="l00542"></a>00542                 xlo=(ei-i)*boxx-fx;xhi=xlo+boxx;
<a name="l00543"></a>00543                 ylo=(ej-j)*boxy-fy;yhi=ylo+boxy;
<a name="l00544"></a>00544                 zlo=(ek-k)*boxz-fz;zhi=zlo+boxz;
<a name="l00545"></a>00545 
<a name="l00546"></a>00546                 <span class="comment">// Carry out plane tests to see if any particle in this block</span>
<a name="l00547"></a>00547                 <span class="comment">// could possibly intersect the cell</span>
<a name="l00548"></a>00548                 <span class="keywordflow">if</span>(ei&gt;i) {
<a name="l00549"></a>00549                         <span class="keywordflow">if</span>(ej&gt;j) {
<a name="l00550"></a>00550                                 <span class="keywordflow">if</span>(ek&gt;k) {<span class="keywordflow">if</span>(corner_test(c,xlo,ylo,zlo,xhi,yhi,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00551"></a>00551                                 <span class="keywordflow">else</span> <span class="keywordflow">if</span>(ek&lt;k) {<span class="keywordflow">if</span>(corner_test(c,xlo,ylo,zhi,xhi,yhi,zlo)) <span class="keywordflow">continue</span>;}
<a name="l00552"></a>00552                                 <span class="keywordflow">else</span> {<span class="keywordflow">if</span>(edge_z_test(c,xlo,ylo,zlo,xhi,yhi,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00553"></a>00553                         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(ej&lt;j) {
<a name="l00554"></a>00554                                 <span class="keywordflow">if</span>(ek&gt;k) {<span class="keywordflow">if</span>(corner_test(c,xlo,yhi,zlo,xhi,ylo,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00555"></a>00555                                 <span class="keywordflow">else</span> <span class="keywordflow">if</span>(ek&lt;k) {<span class="keywordflow">if</span>(corner_test(c,xlo,yhi,zhi,xhi,ylo,zlo)) <span class="keywordflow">continue</span>;}
<a name="l00556"></a>00556                                 <span class="keywordflow">else</span> {<span class="keywordflow">if</span>(edge_z_test(c,xlo,yhi,zlo,xhi,ylo,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00557"></a>00557                         } <span class="keywordflow">else</span> {
<a name="l00558"></a>00558                                 <span class="keywordflow">if</span>(ek&gt;k) {<span class="keywordflow">if</span>(edge_y_test(c,xlo,ylo,zlo,xhi,yhi,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00559"></a>00559                                 <span class="keywordflow">else</span> <span class="keywordflow">if</span>(ek&lt;k) {<span class="keywordflow">if</span>(edge_y_test(c,xlo,ylo,zhi,xhi,yhi,zlo)) <span class="keywordflow">continue</span>;}
<a name="l00560"></a>00560                                 <span class="keywordflow">else</span> {<span class="keywordflow">if</span>(face_x_test(c,xlo,ylo,zlo,yhi,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00561"></a>00561                         }
<a name="l00562"></a>00562                 } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(ei&lt;i) {
<a name="l00563"></a>00563                         <span class="keywordflow">if</span>(ej&gt;j) {
<a name="l00564"></a>00564                                 <span class="keywordflow">if</span>(ek&gt;k) {<span class="keywordflow">if</span>(corner_test(c,xhi,ylo,zlo,xlo,yhi,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00565"></a>00565                                 <span class="keywordflow">else</span> <span class="keywordflow">if</span>(ek&lt;k) {<span class="keywordflow">if</span>(corner_test(c,xhi,ylo,zhi,xlo,yhi,zlo)) <span class="keywordflow">continue</span>;}
<a name="l00566"></a>00566                                 <span class="keywordflow">else</span> {<span class="keywordflow">if</span>(edge_z_test(c,xhi,ylo,zlo,xlo,yhi,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00567"></a>00567                         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(ej&lt;j) {
<a name="l00568"></a>00568                                 <span class="keywordflow">if</span>(ek&gt;k) {<span class="keywordflow">if</span>(corner_test(c,xhi,yhi,zlo,xlo,ylo,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00569"></a>00569                                 <span class="keywordflow">else</span> <span class="keywordflow">if</span>(ek&lt;k) {<span class="keywordflow">if</span>(corner_test(c,xhi,yhi,zhi,xlo,ylo,zlo)) <span class="keywordflow">continue</span>;}
<a name="l00570"></a>00570                                 <span class="keywordflow">else</span> {<span class="keywordflow">if</span>(edge_z_test(c,xhi,yhi,zlo,xlo,ylo,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00571"></a>00571                         } <span class="keywordflow">else</span> {
<a name="l00572"></a>00572                                 <span class="keywordflow">if</span>(ek&gt;k) {<span class="keywordflow">if</span>(edge_y_test(c,xhi,ylo,zlo,xlo,yhi,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00573"></a>00573                                 <span class="keywordflow">else</span> <span class="keywordflow">if</span>(ek&lt;k) {<span class="keywordflow">if</span>(edge_y_test(c,xhi,ylo,zhi,xlo,yhi,zlo)) <span class="keywordflow">continue</span>;}
<a name="l00574"></a>00574                                 <span class="keywordflow">else</span> {<span class="keywordflow">if</span>(face_x_test(c,xhi,ylo,zlo,yhi,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00575"></a>00575                         }
<a name="l00576"></a>00576                 } <span class="keywordflow">else</span> {
<a name="l00577"></a>00577                         <span class="keywordflow">if</span>(ej&gt;j) {
<a name="l00578"></a>00578                                 <span class="keywordflow">if</span>(ek&gt;k) {<span class="keywordflow">if</span>(edge_x_test(c,xlo,ylo,zlo,xhi,yhi,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00579"></a>00579                                 <span class="keywordflow">else</span> <span class="keywordflow">if</span>(ek&lt;k) {<span class="keywordflow">if</span>(edge_x_test(c,xlo,ylo,zhi,xhi,yhi,zlo)) <span class="keywordflow">continue</span>;}
<a name="l00580"></a>00580                                 <span class="keywordflow">else</span> {<span class="keywordflow">if</span>(face_y_test(c,xlo,ylo,zlo,xhi,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00581"></a>00581                         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(ej&lt;j) {
<a name="l00582"></a>00582                                 <span class="keywordflow">if</span>(ek&gt;k) {<span class="keywordflow">if</span>(edge_x_test(c,xlo,yhi,zlo,xhi,ylo,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00583"></a>00583                                 <span class="keywordflow">else</span> <span class="keywordflow">if</span>(ek&lt;k) {<span class="keywordflow">if</span>(edge_x_test(c,xlo,yhi,zhi,xhi,ylo,zlo)) <span class="keywordflow">continue</span>;}
<a name="l00584"></a>00584                                 <span class="keywordflow">else</span> {<span class="keywordflow">if</span>(face_y_test(c,xlo,yhi,zlo,xhi,zhi)) <span class="keywordflow">continue</span>;}
<a name="l00585"></a>00585                         } <span class="keywordflow">else</span> {
<a name="l00586"></a>00586                                 <span class="keywordflow">if</span>(ek&gt;k) {<span class="keywordflow">if</span>(face_z_test(c,xlo,ylo,zlo,xhi,yhi)) <span class="keywordflow">continue</span>;}
<a name="l00587"></a>00587                                 <span class="keywordflow">else</span> <span class="keywordflow">if</span>(ek&lt;k) {<span class="keywordflow">if</span>(face_z_test(c,xlo,ylo,zhi,xhi,yhi)) <span class="keywordflow">continue</span>;}
<a name="l00588"></a>00588                                 <span class="keywordflow">else</span> voro_fatal_error(<span class="stringliteral">&quot;Compute cell routine revisiting central block, which should never\nhappen.&quot;</span>,<a class="code" href="config_8hh.html#ad8e0de9d48da06e86dd87884e4a2d47e">VOROPP_INTERNAL_ERROR</a>);
<a name="l00589"></a>00589                         }
<a name="l00590"></a>00590                 }
<a name="l00591"></a>00591 
<a name="l00592"></a>00592                 <span class="comment">// Now compute the region that we are going to test over, and</span>
<a name="l00593"></a>00593                 <span class="comment">// set a displacement vector for the periodic cases</span>
<a name="l00594"></a>00594                 ijk=con.region_index(ci,cj,ck,ei,ej,ek,qx,qy,qz,disp);
<a name="l00595"></a>00595 
<a name="l00596"></a>00596                 <span class="comment">// Loop over all the elements in the block to test for cuts. It</span>
<a name="l00597"></a>00597                 <span class="comment">// would be possible to exclude some of these cases by testing</span>
<a name="l00598"></a>00598                 <span class="comment">// against mrs, but this will probably not save time.</span>
<a name="l00599"></a>00599                 <span class="keywordflow">if</span>(co[ijk]&gt;0) {
<a name="l00600"></a>00600                         l=0;x2=x-qx;y2=y-qy;z2=z-qz;
<a name="l00601"></a>00601                         <span class="keywordflow">do</span> {
<a name="l00602"></a>00602                                 x1=p[ijk][ps*l]-x2;
<a name="l00603"></a>00603                                 y1=p[ijk][ps*l+1]-y2;
<a name="l00604"></a>00604                                 z1=p[ijk][ps*l+2]-z2;
<a name="l00605"></a>00605                                 rs=con.r_scale(x1*x1+y1*y1+z1*z1,ijk,l);
<a name="l00606"></a>00606                                 <span class="keywordflow">if</span>(!c.nplane(x1,y1,z1,rs,<span class="keywordtype">id</span>[ijk][l])) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00607"></a>00607                                 l++;
<a name="l00608"></a>00608                         } <span class="keywordflow">while</span> (l&lt;co[ijk]);
<a name="l00609"></a>00609                 }
<a name="l00610"></a>00610 
<a name="l00611"></a>00611                 <span class="comment">// If there&#39;s not much memory on the block list then add more</span>
<a name="l00612"></a>00612                 <span class="keywordflow">if</span>((qu_s&lt;=qu_e?(qu_l-qu_e)+(qu_s-qu):qu_s-qu_e)&lt;18) add_list_memory(qu_s,qu_e);
<a name="l00613"></a>00613 
<a name="l00614"></a>00614                 <span class="comment">// Test the neighbors of the current block, and add them to the</span>
<a name="l00615"></a>00615                 <span class="comment">// block list if they haven&#39;t already been tested</span>
<a name="l00616"></a>00616                 add_to_mask(ei,ej,ek,qu_e);
<a name="l00617"></a>00617         }
<a name="l00618"></a>00618 
<a name="l00619"></a>00619         <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00620"></a>00620 }
<a name="l00621"></a>00621 <span class="comment"></span>
<a name="l00622"></a>00622 <span class="comment">/** This function checks to see whether a particular block can possibly have</span>
<a name="l00623"></a>00623 <span class="comment"> * any intersection with a Voronoi cell, for the case when the closest point</span>
<a name="l00624"></a>00624 <span class="comment"> * from the cell center to the block is at a corner.</span>
<a name="l00625"></a>00625 <span class="comment"> * \param[in,out] c a reference to a Voronoi cell.</span>
<a name="l00626"></a>00626 <span class="comment"> * \param[in] (xl,yl,zl) the relative coordinates of the corner of the block</span>
<a name="l00627"></a>00627 <span class="comment"> *                       closest to the cell center.</span>
<a name="l00628"></a>00628 <span class="comment"> * \param[in] (xh,yh,zh) the relative coordinates of the corner of the block</span>
<a name="l00629"></a>00629 <span class="comment"> *                       furthest away from the cell center.</span>
<a name="l00630"></a>00630 <span class="comment"> * \return False if the block may intersect, true if does not. */</span>
<a name="l00631"></a>00631 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00632"></a>00632 <span class="keyword">template</span>&lt;<span class="keyword">class</span> v_cell&gt;
<a name="l00633"></a>00633 <span class="keywordtype">bool</span> <a class="code" href="classvoro_1_1voro__compute.html" title="Template for carrying out Voronoi cell computations.">voro_compute&lt;c_class&gt;::corner_test</a>(v_cell &amp;c,<span class="keywordtype">double</span> xl,<span class="keywordtype">double</span> yl,<span class="keywordtype">double</span> zl,<span class="keywordtype">double</span> xh,<span class="keywordtype">double</span> yh,<span class="keywordtype">double</span> zh) {
<a name="l00634"></a>00634         con.r_prime(xl*xl+yl*yl+zl*zl);
<a name="l00635"></a>00635         <span class="keywordflow">if</span>(c.plane_intersects_guess(xh,yl,zl,con.r_cutoff(xl*xh+yl*yl+zl*zl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00636"></a>00636         <span class="keywordflow">if</span>(c.plane_intersects(xh,yh,zl,con.r_cutoff(xl*xh+yl*yh+zl*zl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00637"></a>00637         <span class="keywordflow">if</span>(c.plane_intersects(xl,yh,zl,con.r_cutoff(xl*xl+yl*yh+zl*zl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00638"></a>00638         <span class="keywordflow">if</span>(c.plane_intersects(xl,yh,zh,con.r_cutoff(xl*xl+yl*yh+zl*zh))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00639"></a>00639         <span class="keywordflow">if</span>(c.plane_intersects(xl,yl,zh,con.r_cutoff(xl*xl+yl*yl+zl*zh))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00640"></a>00640         <span class="keywordflow">if</span>(c.plane_intersects(xh,yl,zh,con.r_cutoff(xl*xh+yl*yl+zl*zh))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00641"></a>00641         <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00642"></a>00642 }
<a name="l00643"></a>00643 <span class="comment"></span>
<a name="l00644"></a>00644 <span class="comment">/** This function checks to see whether a particular block can possibly have</span>
<a name="l00645"></a>00645 <span class="comment"> * any intersection with a Voronoi cell, for the case when the closest point</span>
<a name="l00646"></a>00646 <span class="comment"> * from the cell center to the block is on an edge which points along the x</span>
<a name="l00647"></a>00647 <span class="comment"> * direction.</span>
<a name="l00648"></a>00648 <span class="comment"> * \param[in,out] c a reference to a Voronoi cell.</span>
<a name="l00649"></a>00649 <span class="comment"> * \param[in] (x0,x1) the minimum and maximum relative x coordinates of the</span>
<a name="l00650"></a>00650 <span class="comment"> *                    block.</span>
<a name="l00651"></a>00651 <span class="comment"> * \param[in] (yl,zl) the relative y and z coordinates of the corner of the</span>
<a name="l00652"></a>00652 <span class="comment"> *                    block closest to the cell center.</span>
<a name="l00653"></a>00653 <span class="comment"> * \param[in] (yh,zh) the relative y and z coordinates of the corner of the</span>
<a name="l00654"></a>00654 <span class="comment"> *                    block furthest away from the cell center.</span>
<a name="l00655"></a>00655 <span class="comment"> * \return False if the block may intersect, true if does not. */</span>
<a name="l00656"></a>00656 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00657"></a>00657 <span class="keyword">template</span>&lt;<span class="keyword">class</span> v_cell&gt;
<a name="l00658"></a>00658 <span class="keyword">inline</span> <span class="keywordtype">bool</span> voro_compute&lt;c_class&gt;::edge_x_test(v_cell &amp;c,<span class="keywordtype">double</span> x0,<span class="keywordtype">double</span> yl,<span class="keywordtype">double</span> zl,<span class="keywordtype">double</span> x1,<span class="keywordtype">double</span> yh,<span class="keywordtype">double</span> zh) {
<a name="l00659"></a>00659         con.r_prime(yl*yl+zl*zl);
<a name="l00660"></a>00660         <span class="keywordflow">if</span>(c.plane_intersects_guess(x0,yl,zh,con.r_cutoff(yl*yl+zl*zh))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00661"></a>00661         <span class="keywordflow">if</span>(c.plane_intersects(x1,yl,zh,con.r_cutoff(yl*yl+zl*zh))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00662"></a>00662         <span class="keywordflow">if</span>(c.plane_intersects(x1,yl,zl,con.r_cutoff(yl*yl+zl*zl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00663"></a>00663         <span class="keywordflow">if</span>(c.plane_intersects(x0,yl,zl,con.r_cutoff(yl*yl+zl*zl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00664"></a>00664         <span class="keywordflow">if</span>(c.plane_intersects(x0,yh,zl,con.r_cutoff(yl*yh+zl*zl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00665"></a>00665         <span class="keywordflow">if</span>(c.plane_intersects(x1,yh,zl,con.r_cutoff(yl*yh+zl*zl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00666"></a>00666         <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00667"></a>00667 }
<a name="l00668"></a>00668 <span class="comment"></span>
<a name="l00669"></a>00669 <span class="comment">/** This function checks to see whether a particular block can possibly have</span>
<a name="l00670"></a>00670 <span class="comment"> * any intersection with a Voronoi cell, for the case when the closest point</span>
<a name="l00671"></a>00671 <span class="comment"> * from the cell center to the block is on an edge which points along the y</span>
<a name="l00672"></a>00672 <span class="comment"> * direction.</span>
<a name="l00673"></a>00673 <span class="comment"> * \param[in,out] c a reference to a Voronoi cell.</span>
<a name="l00674"></a>00674 <span class="comment"> * \param[in] (y0,y1) the minimum and maximum relative y coordinates of the</span>
<a name="l00675"></a>00675 <span class="comment"> *                    block.</span>
<a name="l00676"></a>00676 <span class="comment"> * \param[in] (xl,zl) the relative x and z coordinates of the corner of the</span>
<a name="l00677"></a>00677 <span class="comment"> *                    block closest to the cell center.</span>
<a name="l00678"></a>00678 <span class="comment"> * \param[in] (xh,zh) the relative x and z coordinates of the corner of the</span>
<a name="l00679"></a>00679 <span class="comment"> *                    block furthest away from the cell center.</span>
<a name="l00680"></a>00680 <span class="comment"> * \return False if the block may intersect, true if does not. */</span>
<a name="l00681"></a>00681 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00682"></a>00682 <span class="keyword">template</span>&lt;<span class="keyword">class</span> v_cell&gt;
<a name="l00683"></a>00683 <span class="keyword">inline</span> <span class="keywordtype">bool</span> voro_compute&lt;c_class&gt;::edge_y_test(v_cell &amp;c,<span class="keywordtype">double</span> xl,<span class="keywordtype">double</span> y0,<span class="keywordtype">double</span> zl,<span class="keywordtype">double</span> xh,<span class="keywordtype">double</span> y1,<span class="keywordtype">double</span> zh) {
<a name="l00684"></a>00684         con.r_prime(xl*xl+zl*zl);
<a name="l00685"></a>00685         <span class="keywordflow">if</span>(c.plane_intersects_guess(xl,y0,zh,con.r_cutoff(xl*xl+zl*zh))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00686"></a>00686         <span class="keywordflow">if</span>(c.plane_intersects(xl,y1,zh,con.r_cutoff(xl*xl+zl*zh))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00687"></a>00687         <span class="keywordflow">if</span>(c.plane_intersects(xl,y1,zl,con.r_cutoff(xl*xl+zl*zl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00688"></a>00688         <span class="keywordflow">if</span>(c.plane_intersects(xl,y0,zl,con.r_cutoff(xl*xl+zl*zl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00689"></a>00689         <span class="keywordflow">if</span>(c.plane_intersects(xh,y0,zl,con.r_cutoff(xl*xh+zl*zl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00690"></a>00690         <span class="keywordflow">if</span>(c.plane_intersects(xh,y1,zl,con.r_cutoff(xl*xh+zl*zl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00691"></a>00691         <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00692"></a>00692 }
<a name="l00693"></a>00693 <span class="comment"></span>
<a name="l00694"></a>00694 <span class="comment">/** This function checks to see whether a particular block can possibly have</span>
<a name="l00695"></a>00695 <span class="comment"> * any intersection with a Voronoi cell, for the case when the closest point</span>
<a name="l00696"></a>00696 <span class="comment"> * from the cell center to the block is on an edge which points along the z</span>
<a name="l00697"></a>00697 <span class="comment"> * direction.</span>
<a name="l00698"></a>00698 <span class="comment"> * \param[in,out] c a reference to a Voronoi cell.</span>
<a name="l00699"></a>00699 <span class="comment"> * \param[in] (z0,z1) the minimum and maximum relative z coordinates of the block.</span>
<a name="l00700"></a>00700 <span class="comment"> * \param[in] (xl,yl) the relative x and y coordinates of the corner of the</span>
<a name="l00701"></a>00701 <span class="comment"> *                    block closest to the cell center.</span>
<a name="l00702"></a>00702 <span class="comment"> * \param[in] (xh,yh) the relative x and y coordinates of the corner of the</span>
<a name="l00703"></a>00703 <span class="comment"> *                    block furthest away from the cell center.</span>
<a name="l00704"></a>00704 <span class="comment"> * \return False if the block may intersect, true if does not. */</span>
<a name="l00705"></a>00705 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00706"></a>00706 <span class="keyword">template</span>&lt;<span class="keyword">class</span> v_cell&gt;
<a name="l00707"></a>00707 <span class="keyword">inline</span> <span class="keywordtype">bool</span> voro_compute&lt;c_class&gt;::edge_z_test(v_cell &amp;c,<span class="keywordtype">double</span> xl,<span class="keywordtype">double</span> yl,<span class="keywordtype">double</span> z0,<span class="keywordtype">double</span> xh,<span class="keywordtype">double</span> yh,<span class="keywordtype">double</span> z1) {
<a name="l00708"></a>00708         con.r_prime(xl*xl+yl*yl);
<a name="l00709"></a>00709         <span class="keywordflow">if</span>(c.plane_intersects_guess(xl,yh,z0,con.r_cutoff(xl*xl+yl*yh))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00710"></a>00710         <span class="keywordflow">if</span>(c.plane_intersects(xl,yh,z1,con.r_cutoff(xl*xl+yl*yh))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00711"></a>00711         <span class="keywordflow">if</span>(c.plane_intersects(xl,yl,z1,con.r_cutoff(xl*xl+yl*yl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00712"></a>00712         <span class="keywordflow">if</span>(c.plane_intersects(xl,yl,z0,con.r_cutoff(xl*xl+yl*yl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00713"></a>00713         <span class="keywordflow">if</span>(c.plane_intersects(xh,yl,z0,con.r_cutoff(xl*xh+yl*yl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00714"></a>00714         <span class="keywordflow">if</span>(c.plane_intersects(xh,yl,z1,con.r_cutoff(xl*xh+yl*yl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00715"></a>00715         <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00716"></a>00716 }
<a name="l00717"></a>00717 <span class="comment"></span>
<a name="l00718"></a>00718 <span class="comment">/** This function checks to see whether a particular block can possibly have</span>
<a name="l00719"></a>00719 <span class="comment"> * any intersection with a Voronoi cell, for the case when the closest point</span>
<a name="l00720"></a>00720 <span class="comment"> * from the cell center to the block is on a face aligned with the x direction.</span>
<a name="l00721"></a>00721 <span class="comment"> * \param[in,out] c a reference to a Voronoi cell.</span>
<a name="l00722"></a>00722 <span class="comment"> * \param[in] xl the minimum distance from the cell center to the face.</span>
<a name="l00723"></a>00723 <span class="comment"> * \param[in] (y0,y1) the minimum and maximum relative y coordinates of the</span>
<a name="l00724"></a>00724 <span class="comment"> *                    block.</span>
<a name="l00725"></a>00725 <span class="comment"> * \param[in] (z0,z1) the minimum and maximum relative z coordinates of the</span>
<a name="l00726"></a>00726 <span class="comment"> *                    block.</span>
<a name="l00727"></a>00727 <span class="comment"> * \return False if the block may intersect, true if does not. */</span>
<a name="l00728"></a>00728 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00729"></a>00729 <span class="keyword">template</span>&lt;<span class="keyword">class</span> v_cell&gt;
<a name="l00730"></a>00730 <span class="keyword">inline</span> <span class="keywordtype">bool</span> voro_compute&lt;c_class&gt;::face_x_test(v_cell &amp;c,<span class="keywordtype">double</span> xl,<span class="keywordtype">double</span> y0,<span class="keywordtype">double</span> z0,<span class="keywordtype">double</span> y1,<span class="keywordtype">double</span> z1) {
<a name="l00731"></a>00731         con.r_prime(xl*xl);
<a name="l00732"></a>00732         <span class="keywordflow">if</span>(c.plane_intersects_guess(xl,y0,z0,con.r_cutoff(xl*xl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00733"></a>00733         <span class="keywordflow">if</span>(c.plane_intersects(xl,y0,z1,con.r_cutoff(xl*xl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00734"></a>00734         <span class="keywordflow">if</span>(c.plane_intersects(xl,y1,z1,con.r_cutoff(xl*xl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00735"></a>00735         <span class="keywordflow">if</span>(c.plane_intersects(xl,y1,z0,con.r_cutoff(xl*xl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00736"></a>00736         <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00737"></a>00737 }
<a name="l00738"></a>00738 <span class="comment"></span>
<a name="l00739"></a>00739 <span class="comment">/** This function checks to see whether a particular block can possibly have</span>
<a name="l00740"></a>00740 <span class="comment"> * any intersection with a Voronoi cell, for the case when the closest point</span>
<a name="l00741"></a>00741 <span class="comment"> * from the cell center to the block is on a face aligned with the y direction.</span>
<a name="l00742"></a>00742 <span class="comment"> * \param[in,out] c a reference to a Voronoi cell.</span>
<a name="l00743"></a>00743 <span class="comment"> * \param[in] yl the minimum distance from the cell center to the face.</span>
<a name="l00744"></a>00744 <span class="comment"> * \param[in] (x0,x1) the minimum and maximum relative x coordinates of the</span>
<a name="l00745"></a>00745 <span class="comment"> *                    block.</span>
<a name="l00746"></a>00746 <span class="comment"> * \param[in] (z0,z1) the minimum and maximum relative z coordinates of the</span>
<a name="l00747"></a>00747 <span class="comment"> *                    block.</span>
<a name="l00748"></a>00748 <span class="comment"> * \return False if the block may intersect, true if does not. */</span>
<a name="l00749"></a>00749 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00750"></a>00750 <span class="keyword">template</span>&lt;<span class="keyword">class</span> v_cell&gt;
<a name="l00751"></a>00751 <span class="keyword">inline</span> <span class="keywordtype">bool</span> voro_compute&lt;c_class&gt;::face_y_test(v_cell &amp;c,<span class="keywordtype">double</span> x0,<span class="keywordtype">double</span> yl,<span class="keywordtype">double</span> z0,<span class="keywordtype">double</span> x1,<span class="keywordtype">double</span> z1) {
<a name="l00752"></a>00752         con.r_prime(yl*yl);
<a name="l00753"></a>00753         <span class="keywordflow">if</span>(c.plane_intersects_guess(x0,yl,z0,con.r_cutoff(yl*yl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00754"></a>00754         <span class="keywordflow">if</span>(c.plane_intersects(x0,yl,z1,con.r_cutoff(yl*yl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00755"></a>00755         <span class="keywordflow">if</span>(c.plane_intersects(x1,yl,z1,con.r_cutoff(yl*yl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00756"></a>00756         <span class="keywordflow">if</span>(c.plane_intersects(x1,yl,z0,con.r_cutoff(yl*yl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00757"></a>00757         <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00758"></a>00758 }
<a name="l00759"></a>00759 <span class="comment"></span>
<a name="l00760"></a>00760 <span class="comment">/** This function checks to see whether a particular block can possibly have</span>
<a name="l00761"></a>00761 <span class="comment"> * any intersection with a Voronoi cell, for the case when the closest point</span>
<a name="l00762"></a>00762 <span class="comment"> * from the cell center to the block is on a face aligned with the z direction.</span>
<a name="l00763"></a>00763 <span class="comment"> * \param[in,out] c a reference to a Voronoi cell.</span>
<a name="l00764"></a>00764 <span class="comment"> * \param[in] zl the minimum distance from the cell center to the face.</span>
<a name="l00765"></a>00765 <span class="comment"> * \param[in] (x0,x1) the minimum and maximum relative x coordinates of the</span>
<a name="l00766"></a>00766 <span class="comment"> *                    block.</span>
<a name="l00767"></a>00767 <span class="comment"> * \param[in] (y0,y1) the minimum and maximum relative y coordinates of the</span>
<a name="l00768"></a>00768 <span class="comment"> *                    block.</span>
<a name="l00769"></a>00769 <span class="comment"> * \return False if the block may intersect, true if does not. */</span>
<a name="l00770"></a>00770 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00771"></a>00771 <span class="keyword">template</span>&lt;<span class="keyword">class</span> v_cell&gt;
<a name="l00772"></a>00772 <span class="keyword">inline</span> <span class="keywordtype">bool</span> voro_compute&lt;c_class&gt;::face_z_test(v_cell &amp;c,<span class="keywordtype">double</span> x0,<span class="keywordtype">double</span> y0,<span class="keywordtype">double</span> zl,<span class="keywordtype">double</span> x1,<span class="keywordtype">double</span> y1) {
<a name="l00773"></a>00773         con.r_prime(zl*zl);
<a name="l00774"></a>00774         <span class="keywordflow">if</span>(c.plane_intersects_guess(x0,y0,zl,con.r_cutoff(zl*zl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00775"></a>00775         <span class="keywordflow">if</span>(c.plane_intersects(x0,y1,zl,con.r_cutoff(zl*zl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00776"></a>00776         <span class="keywordflow">if</span>(c.plane_intersects(x1,y1,zl,con.r_cutoff(zl*zl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00777"></a>00777         <span class="keywordflow">if</span>(c.plane_intersects(x1,y0,zl,con.r_cutoff(zl*zl))) <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00778"></a>00778         <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00779"></a>00779 }
<a name="l00780"></a>00780 
<a name="l00781"></a>00781 <span class="comment"></span>
<a name="l00782"></a>00782 <span class="comment">/** This routine checks to see whether a point is within a particular distance</span>
<a name="l00783"></a>00783 <span class="comment"> * of a nearby region. If the point is within the distance of the region, then</span>
<a name="l00784"></a>00784 <span class="comment"> * the routine returns true, and computes the maximum distance from the point</span>
<a name="l00785"></a>00785 <span class="comment"> * to the region. Otherwise, the routine returns false.</span>
<a name="l00786"></a>00786 <span class="comment"> * \param[in] (di,dj,dk) the position of the nearby region to be tested,</span>
<a name="l00787"></a>00787 <span class="comment"> *                       relative to the region that the point is in.</span>
<a name="l00788"></a>00788 <span class="comment"> * \param[in] (fx,fy,fz) the displacement of the point within its region.</span>
<a name="l00789"></a>00789 <span class="comment"> * \param[in] (gxs,gys,gzs) the maximum squared distances from the point to the</span>
<a name="l00790"></a>00790 <span class="comment"> *                          sides of its region.</span>
<a name="l00791"></a>00791 <span class="comment"> * \param[out] crs a reference in which to return the maximum distance to the</span>
<a name="l00792"></a>00792 <span class="comment"> *                 region (only computed if the routine returns false).</span>
<a name="l00793"></a>00793 <span class="comment"> * \param[in] mrs the distance to be tested.</span>
<a name="l00794"></a>00794 <span class="comment"> * \return True if the region is further away than mrs, false if the region in</span>
<a name="l00795"></a>00795 <span class="comment"> *         within mrs. */</span>
<a name="l00796"></a>00796 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00797"></a>00797 <span class="keywordtype">bool</span> voro_compute&lt;c_class&gt;::compute_min_max_radius(<span class="keywordtype">int</span> di,<span class="keywordtype">int</span> dj,<span class="keywordtype">int</span> dk,<span class="keywordtype">double</span> fx,<span class="keywordtype">double</span> fy,<span class="keywordtype">double</span> fz,<span class="keywordtype">double</span> gxs,<span class="keywordtype">double</span> gys,<span class="keywordtype">double</span> gzs,<span class="keywordtype">double</span> &amp;crs,<span class="keywordtype">double</span> mrs) {
<a name="l00798"></a>00798         <span class="keywordtype">double</span> xlo,ylo,zlo;
<a name="l00799"></a>00799         <span class="keywordflow">if</span>(di&gt;0) {
<a name="l00800"></a>00800                 xlo=di*boxx-fx;
<a name="l00801"></a>00801                 crs=xlo*xlo;
<a name="l00802"></a>00802                 <span class="keywordflow">if</span>(dj&gt;0) {
<a name="l00803"></a>00803                         ylo=dj*boxy-fy;
<a name="l00804"></a>00804                         crs+=ylo*ylo;
<a name="l00805"></a>00805                         <span class="keywordflow">if</span>(dk&gt;0) {
<a name="l00806"></a>00806                                 zlo=dk*boxz-fz;
<a name="l00807"></a>00807                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00808"></a>00808                                 crs+=bxsq+2*(boxx*xlo+boxy*ylo+boxz*zlo);
<a name="l00809"></a>00809                         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(dk&lt;0) {
<a name="l00810"></a>00810                                 zlo=(dk+1)*boxz-fz;
<a name="l00811"></a>00811                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00812"></a>00812                                 crs+=bxsq+2*(boxx*xlo+boxy*ylo-boxz*zlo);
<a name="l00813"></a>00813                         } <span class="keywordflow">else</span> {
<a name="l00814"></a>00814                                 <span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00815"></a>00815                                 crs+=boxx*(2*xlo+boxx)+boxy*(2*ylo+boxy)+gzs;
<a name="l00816"></a>00816                         }
<a name="l00817"></a>00817                 } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(dj&lt;0) {
<a name="l00818"></a>00818                         ylo=(dj+1)*boxy-fy;
<a name="l00819"></a>00819                         crs+=ylo*ylo;
<a name="l00820"></a>00820                         <span class="keywordflow">if</span>(dk&gt;0) {
<a name="l00821"></a>00821                                 zlo=dk*boxz-fz;
<a name="l00822"></a>00822                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00823"></a>00823                                 crs+=bxsq+2*(boxx*xlo-boxy*ylo+boxz*zlo);
<a name="l00824"></a>00824                         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(dk&lt;0) {
<a name="l00825"></a>00825                                 zlo=(dk+1)*boxz-fz;
<a name="l00826"></a>00826                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00827"></a>00827                                 crs+=bxsq+2*(boxx*xlo-boxy*ylo-boxz*zlo);
<a name="l00828"></a>00828                         } <span class="keywordflow">else</span> {
<a name="l00829"></a>00829                                 <span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00830"></a>00830                                 crs+=boxx*(2*xlo+boxx)+boxy*(-2*ylo+boxy)+gzs;
<a name="l00831"></a>00831                         }
<a name="l00832"></a>00832                 } <span class="keywordflow">else</span> {
<a name="l00833"></a>00833                         <span class="keywordflow">if</span>(dk&gt;0) {
<a name="l00834"></a>00834                                 zlo=dk*boxz-fz;
<a name="l00835"></a>00835                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00836"></a>00836                                 crs+=boxz*(2*zlo+boxz);
<a name="l00837"></a>00837                         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(dk&lt;0) {
<a name="l00838"></a>00838                                 zlo=(dk+1)*boxz-fz;
<a name="l00839"></a>00839                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00840"></a>00840                                 crs+=boxz*(-2*zlo+boxz);
<a name="l00841"></a>00841                         } <span class="keywordflow">else</span> {
<a name="l00842"></a>00842                                 <span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00843"></a>00843                                 crs+=gzs;
<a name="l00844"></a>00844                         }
<a name="l00845"></a>00845                         crs+=gys+boxx*(2*xlo+boxx);
<a name="l00846"></a>00846                 }
<a name="l00847"></a>00847         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(di&lt;0) {
<a name="l00848"></a>00848                 xlo=(di+1)*boxx-fx;
<a name="l00849"></a>00849                 crs=xlo*xlo;
<a name="l00850"></a>00850                 <span class="keywordflow">if</span>(dj&gt;0) {
<a name="l00851"></a>00851                         ylo=dj*boxy-fy;
<a name="l00852"></a>00852                         crs+=ylo*ylo;
<a name="l00853"></a>00853                         <span class="keywordflow">if</span>(dk&gt;0) {
<a name="l00854"></a>00854                                 zlo=dk*boxz-fz;
<a name="l00855"></a>00855                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00856"></a>00856                                 crs+=bxsq+2*(-boxx*xlo+boxy*ylo+boxz*zlo);
<a name="l00857"></a>00857                         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(dk&lt;0) {
<a name="l00858"></a>00858                                 zlo=(dk+1)*boxz-fz;
<a name="l00859"></a>00859                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00860"></a>00860                                 crs+=bxsq+2*(-boxx*xlo+boxy*ylo-boxz*zlo);
<a name="l00861"></a>00861                         } <span class="keywordflow">else</span> {
<a name="l00862"></a>00862                                 <span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00863"></a>00863                                 crs+=boxx*(-2*xlo+boxx)+boxy*(2*ylo+boxy)+gzs;
<a name="l00864"></a>00864                         }
<a name="l00865"></a>00865                 } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(dj&lt;0) {
<a name="l00866"></a>00866                         ylo=(dj+1)*boxy-fy;
<a name="l00867"></a>00867                         crs+=ylo*ylo;
<a name="l00868"></a>00868                         <span class="keywordflow">if</span>(dk&gt;0) {
<a name="l00869"></a>00869                                 zlo=dk*boxz-fz;
<a name="l00870"></a>00870                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00871"></a>00871                                 crs+=bxsq+2*(-boxx*xlo-boxy*ylo+boxz*zlo);
<a name="l00872"></a>00872                         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(dk&lt;0) {
<a name="l00873"></a>00873                                 zlo=(dk+1)*boxz-fz;
<a name="l00874"></a>00874                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00875"></a>00875                                 crs+=bxsq+2*(-boxx*xlo-boxy*ylo-boxz*zlo);
<a name="l00876"></a>00876                         } <span class="keywordflow">else</span> {
<a name="l00877"></a>00877                                 <span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00878"></a>00878                                 crs+=boxx*(-2*xlo+boxx)+boxy*(-2*ylo+boxy)+gzs;
<a name="l00879"></a>00879                         }
<a name="l00880"></a>00880                 } <span class="keywordflow">else</span> {
<a name="l00881"></a>00881                         <span class="keywordflow">if</span>(dk&gt;0) {
<a name="l00882"></a>00882                                 zlo=dk*boxz-fz;
<a name="l00883"></a>00883                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00884"></a>00884                                 crs+=boxz*(2*zlo+boxz);
<a name="l00885"></a>00885                         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(dk&lt;0) {
<a name="l00886"></a>00886                                 zlo=(dk+1)*boxz-fz;
<a name="l00887"></a>00887                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00888"></a>00888                                 crs+=boxz*(-2*zlo+boxz);
<a name="l00889"></a>00889                         } <span class="keywordflow">else</span> {
<a name="l00890"></a>00890                                 <span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00891"></a>00891                                 crs+=gzs;
<a name="l00892"></a>00892                         }
<a name="l00893"></a>00893                         crs+=gys+boxx*(-2*xlo+boxx);
<a name="l00894"></a>00894                 }
<a name="l00895"></a>00895         } <span class="keywordflow">else</span> {
<a name="l00896"></a>00896                 <span class="keywordflow">if</span>(dj&gt;0) {
<a name="l00897"></a>00897                         ylo=dj*boxy-fy;
<a name="l00898"></a>00898                         crs=ylo*ylo;
<a name="l00899"></a>00899                         <span class="keywordflow">if</span>(dk&gt;0) {
<a name="l00900"></a>00900                                 zlo=dk*boxz-fz;
<a name="l00901"></a>00901                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00902"></a>00902                                 crs+=boxz*(2*zlo+boxz);
<a name="l00903"></a>00903                         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(dk&lt;0) {
<a name="l00904"></a>00904                                 zlo=(dk+1)*boxz-fz;
<a name="l00905"></a>00905                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00906"></a>00906                                 crs+=boxz*(-2*zlo+boxz);
<a name="l00907"></a>00907                         } <span class="keywordflow">else</span> {
<a name="l00908"></a>00908                                 <span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00909"></a>00909                                 crs+=gzs;
<a name="l00910"></a>00910                         }
<a name="l00911"></a>00911                         crs+=boxy*(2*ylo+boxy);
<a name="l00912"></a>00912                 } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(dj&lt;0) {
<a name="l00913"></a>00913                         ylo=(dj+1)*boxy-fy;
<a name="l00914"></a>00914                         crs=ylo*ylo;
<a name="l00915"></a>00915                         <span class="keywordflow">if</span>(dk&gt;0) {
<a name="l00916"></a>00916                                 zlo=dk*boxz-fz;
<a name="l00917"></a>00917                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00918"></a>00918                                 crs+=boxz*(2*zlo+boxz);
<a name="l00919"></a>00919                         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(dk&lt;0) {
<a name="l00920"></a>00920                                 zlo=(dk+1)*boxz-fz;
<a name="l00921"></a>00921                                 crs+=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00922"></a>00922                                 crs+=boxz*(-2*zlo+boxz);
<a name="l00923"></a>00923                         } <span class="keywordflow">else</span> {
<a name="l00924"></a>00924                                 <span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00925"></a>00925                                 crs+=gzs;
<a name="l00926"></a>00926                         }
<a name="l00927"></a>00927                         crs+=boxy*(-2*ylo+boxy);
<a name="l00928"></a>00928                 } <span class="keywordflow">else</span> {
<a name="l00929"></a>00929                         <span class="keywordflow">if</span>(dk&gt;0) {
<a name="l00930"></a>00930                                 zlo=dk*boxz-fz;crs=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00931"></a>00931                                 crs+=boxz*(2*zlo+boxz);
<a name="l00932"></a>00932                         } <span class="keywordflow">else</span> <span class="keywordflow">if</span>(dk&lt;0) {
<a name="l00933"></a>00933                                 zlo=(dk+1)*boxz-fz;crs=zlo*zlo;<span class="keywordflow">if</span>(con.r_ctest(crs,mrs)) <span class="keywordflow">return</span> <span class="keyword">true</span>;
<a name="l00934"></a>00934                                 crs+=boxz*(-2*zlo+boxz);
<a name="l00935"></a>00935                         } <span class="keywordflow">else</span> {
<a name="l00936"></a>00936                                 crs=0;
<a name="l00937"></a>00937                                 voro_fatal_error(<span class="stringliteral">&quot;Min/max radius function called for central block, which should never\nhappen.&quot;</span>,<a class="code" href="config_8hh.html#ad8e0de9d48da06e86dd87884e4a2d47e">VOROPP_INTERNAL_ERROR</a>);
<a name="l00938"></a>00938                         }
<a name="l00939"></a>00939                         crs+=gys;
<a name="l00940"></a>00940                 }
<a name="l00941"></a>00941                 crs+=gxs;
<a name="l00942"></a>00942         }
<a name="l00943"></a>00943         <span class="keywordflow">return</span> <span class="keyword">false</span>;
<a name="l00944"></a>00944 }
<a name="l00945"></a>00945 
<a name="l00946"></a>00946 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00947"></a>00947 <span class="keywordtype">bool</span> voro_compute&lt;c_class&gt;::compute_min_radius(<span class="keywordtype">int</span> di,<span class="keywordtype">int</span> dj,<span class="keywordtype">int</span> dk,<span class="keywordtype">double</span> fx,<span class="keywordtype">double</span> fy,<span class="keywordtype">double</span> fz,<span class="keywordtype">double</span> mrs) {
<a name="l00948"></a>00948         <span class="keywordtype">double</span> t,crs;
<a name="l00949"></a>00949 
<a name="l00950"></a>00950         <span class="keywordflow">if</span>(di&gt;0) {t=di*boxx-fx;crs=t*t;}
<a name="l00951"></a>00951         <span class="keywordflow">else</span> <span class="keywordflow">if</span>(di&lt;0) {t=(di+1)*boxx-fx;crs=t*t;}
<a name="l00952"></a>00952         <span class="keywordflow">else</span> crs=0;
<a name="l00953"></a>00953 
<a name="l00954"></a>00954         <span class="keywordflow">if</span>(dj&gt;0) {t=dj*boxy-fy;crs+=t*t;}
<a name="l00955"></a>00955         <span class="keywordflow">else</span> <span class="keywordflow">if</span>(dj&lt;0) {t=(dj+1)*boxy-fy;crs+=t*t;}
<a name="l00956"></a>00956 
<a name="l00957"></a>00957         <span class="keywordflow">if</span>(dk&gt;0) {t=dk*boxz-fz;crs+=t*t;}
<a name="l00958"></a>00958         <span class="keywordflow">else</span> <span class="keywordflow">if</span>(dk&lt;0) {t=(dk+1)*boxz-fz;crs+=t*t;}
<a name="l00959"></a>00959 
<a name="l00960"></a>00960         <span class="keywordflow">return</span> crs&gt;con.r_max_add(mrs);
<a name="l00961"></a>00961 }
<a name="l00962"></a>00962 <span class="comment"></span>
<a name="l00963"></a>00963 <span class="comment">/** Adds memory to the queue.</span>
<a name="l00964"></a>00964 <span class="comment"> * \param[in,out] qu_s a reference to the queue start pointer.</span>
<a name="l00965"></a>00965 <span class="comment"> * \param[in,out] qu_e a reference to the queue end pointer. */</span>
<a name="l00966"></a>00966 <span class="keyword">template</span>&lt;<span class="keyword">class</span> c_<span class="keyword">class</span>&gt;
<a name="l00967"></a>00967 <span class="keyword">inline</span> <span class="keywordtype">void</span> voro_compute&lt;c_class&gt;::add_list_memory(<span class="keywordtype">int</span>*&amp; qu_s,<span class="keywordtype">int</span>*&amp; qu_e) {
<a name="l00968"></a>00968         qu_size&lt;&lt;=1;
<a name="l00969"></a>00969         <span class="keywordtype">int</span> *qu_n=<span class="keyword">new</span> <span class="keywordtype">int</span>[qu_size],*qu_c=qu_n;
<a name="l00970"></a>00970 <span class="preprocessor">#if VOROPP_VERBOSE &gt;=2</span>
<a name="l00971"></a>00971 <span class="preprocessor"></span>        fprintf(stderr,<span class="stringliteral">&quot;List memory scaled up to %d\n&quot;</span>,qu_size);
<a name="l00972"></a>00972 <span class="preprocessor">#endif</span>
<a name="l00973"></a>00973 <span class="preprocessor"></span>        <span class="keywordflow">if</span>(qu_s&lt;=qu_e) {
<a name="l00974"></a>00974                 <span class="keywordflow">while</span>(qu_s&lt;qu_e) *(qu_c++)=*(qu_s++);
<a name="l00975"></a>00975         } <span class="keywordflow">else</span> {
<a name="l00976"></a>00976                 <span class="keywordflow">while</span>(qu_s&lt;qu_l) *(qu_c++)=*(qu_s++);qu_s=qu;
<a name="l00977"></a>00977                 <span class="keywordflow">while</span>(qu_s&lt;qu_e) *(qu_c++)=*(qu_s++);
<a name="l00978"></a>00978         }
<a name="l00979"></a>00979         <span class="keyword">delete</span> [] qu;
<a name="l00980"></a>00980         qu_s=qu=qu_n;
<a name="l00981"></a>00981         qu_l=qu+qu_size;
<a name="l00982"></a>00982         qu_e=qu_c;
<a name="l00983"></a>00983 }
<a name="l00984"></a>00984 
<a name="l00985"></a>00985 <span class="comment">// Explicit template instantiation</span>
<a name="l00986"></a>00986 <span class="keyword">template</span> <a class="code" href="classvoro_1_1voro__compute.html#a03e689aa5bb5886cec3db68a692de122">voro_compute&lt;container&gt;::voro_compute</a>(container&amp;,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>);
<a name="l00987"></a>00987 <span class="keyword">template</span> <a class="code" href="classvoro_1_1voro__compute.html#a03e689aa5bb5886cec3db68a692de122">voro_compute&lt;container_poly&gt;::voro_compute</a>(container_poly&amp;,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>);
<a name="l00988"></a>00988 <span class="keyword">template</span> <span class="keywordtype">bool</span> <a class="code" href="classvoro_1_1voro__compute.html#a09ac0d2470ba4f62482d0cfed4eafbc0">voro_compute&lt;container&gt;::compute_cell</a>(voronoicell&amp;,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>);
<a name="l00989"></a>00989 <span class="keyword">template</span> <span class="keywordtype">bool</span> <a class="code" href="classvoro_1_1voro__compute.html#a09ac0d2470ba4f62482d0cfed4eafbc0">voro_compute&lt;container&gt;::compute_cell</a>(voronoicell_neighbor&amp;,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>);
<a name="l00990"></a>00990 <span class="keyword">template</span> <span class="keywordtype">void</span> <a class="code" href="classvoro_1_1voro__compute.html#aa0b01474a0cf0b230b736e7352404d8d">voro_compute&lt;container&gt;::find_voronoi_cell</a>(<span class="keywordtype">double</span>,<span class="keywordtype">double</span>,<span class="keywordtype">double</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,particle_record&amp;,<span class="keywordtype">double</span>&amp;);
<a name="l00991"></a>00991 <span class="keyword">template</span> <span class="keywordtype">bool</span> <a class="code" href="classvoro_1_1voro__compute.html#a09ac0d2470ba4f62482d0cfed4eafbc0">voro_compute&lt;container_poly&gt;::compute_cell</a>(voronoicell&amp;,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>);
<a name="l00992"></a>00992 <span class="keyword">template</span> <span class="keywordtype">bool</span> <a class="code" href="classvoro_1_1voro__compute.html#a09ac0d2470ba4f62482d0cfed4eafbc0">voro_compute&lt;container_poly&gt;::compute_cell</a>(voronoicell_neighbor&amp;,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>);
<a name="l00993"></a>00993 <span class="keyword">template</span> <span class="keywordtype">void</span> <a class="code" href="classvoro_1_1voro__compute.html#aa0b01474a0cf0b230b736e7352404d8d">voro_compute&lt;container_poly&gt;::find_voronoi_cell</a>(<span class="keywordtype">double</span>,<span class="keywordtype">double</span>,<span class="keywordtype">double</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,particle_record&amp;,<span class="keywordtype">double</span>&amp;);
<a name="l00994"></a>00994 
<a name="l00995"></a>00995 <span class="comment">// Explicit template instantiation</span>
<a name="l00996"></a>00996 <span class="keyword">template</span> <a class="code" href="classvoro_1_1voro__compute.html#a03e689aa5bb5886cec3db68a692de122">voro_compute&lt;container_periodic&gt;::voro_compute</a>(container_periodic&amp;,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>);
<a name="l00997"></a>00997 <span class="keyword">template</span> <a class="code" href="classvoro_1_1voro__compute.html#a03e689aa5bb5886cec3db68a692de122">voro_compute&lt;container_periodic_poly&gt;::voro_compute</a>(container_periodic_poly&amp;,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>);
<a name="l00998"></a>00998 <span class="keyword">template</span> <span class="keywordtype">bool</span> <a class="code" href="classvoro_1_1voro__compute.html#a09ac0d2470ba4f62482d0cfed4eafbc0">voro_compute&lt;container_periodic&gt;::compute_cell</a>(voronoicell&amp;,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>);
<a name="l00999"></a>00999 <span class="keyword">template</span> <span class="keywordtype">bool</span> <a class="code" href="classvoro_1_1voro__compute.html#a09ac0d2470ba4f62482d0cfed4eafbc0">voro_compute&lt;container_periodic&gt;::compute_cell</a>(voronoicell_neighbor&amp;,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>);
<a name="l01000"></a>01000 <span class="keyword">template</span> <span class="keywordtype">void</span> <a class="code" href="classvoro_1_1voro__compute.html#aa0b01474a0cf0b230b736e7352404d8d">voro_compute&lt;container_periodic&gt;::find_voronoi_cell</a>(<span class="keywordtype">double</span>,<span class="keywordtype">double</span>,<span class="keywordtype">double</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,particle_record&amp;,<span class="keywordtype">double</span>&amp;);
<a name="l01001"></a>01001 <span class="keyword">template</span> <span class="keywordtype">bool</span> <a class="code" href="classvoro_1_1voro__compute.html#a09ac0d2470ba4f62482d0cfed4eafbc0">voro_compute&lt;container_periodic_poly&gt;::compute_cell</a>(voronoicell&amp;,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>);
<a name="l01002"></a>01002 <span class="keyword">template</span> <span class="keywordtype">bool</span> <a class="code" href="classvoro_1_1voro__compute.html#a09ac0d2470ba4f62482d0cfed4eafbc0">voro_compute&lt;container_periodic_poly&gt;::compute_cell</a>(voronoicell_neighbor&amp;,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>);
<a name="l01003"></a>01003 <span class="keyword">template</span> <span class="keywordtype">void</span> <a class="code" href="classvoro_1_1voro__compute.html#aa0b01474a0cf0b230b736e7352404d8d">voro_compute&lt;container_periodic_poly&gt;::find_voronoi_cell</a>(<span class="keywordtype">double</span>,<span class="keywordtype">double</span>,<span class="keywordtype">double</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,<span class="keywordtype">int</span>,particle_record&amp;,<span class="keywordtype">double</span>&amp;);
<a name="l01004"></a>01004 
<a name="l01005"></a>01005 }
</pre></div></div>
</div>


<hr class="footer"/><address class="footer"><small>
Generated on Fri Sep 23 2011 22:49:06 for Voro++ by &#160;<a href="http://www.doxygen.org/index.html">
<img class="footer" src="doxygen.png" alt="doxygen"/>
</a> 1.7.5.1
</small></address>

</body>
</html>
